C++博客-yzhw@ujs code my life~-随笔分类-combination math

pku3904 容斥原理的运用，好题！

yzhw — Thu, 16 Feb 2012 18:03:00 GMT

解法发现网上一个大牛写的很好，就转载过来吧。可怜的我，开始没想到算法就算了，想到算法后又刻意依赖STL结果o(N)写成o(logN)成功葬送。

解法

题意：给你n个数，求GCD(gcd(a,b),gcd(c,d))=1的方案数，注意a,b,c,d并不一定两两互质，有多组数据

本来这个题的题解有一大把，但没有讲题解的只有贴代码的。

本来一直在做题，没有什么时间发题解，但这个题加深了我对容斥原理的理解，所以讲一下

这个题的算法是个伪多项式

首先，先将算法流程说一下，原理后面会有

Step 1：用筛法筛出10000内的素数表

Step 2：组合素数，用bool数组记录由m(m<=5)个素数相乘所得数的m的奇偶

例如：182=2*7*13 ———> m=3 so，bool[182]=false

2=2 ——>m=1 so，bool[2]=false

91=7*13 ——>m=2 so，bool[91]=true

注意12=2^2*3等这种是B=p1^k1*p2^k2+...这种有质因数指数不为一的合数不要处理因为不会用到

以上是预处理

Step 3：读入当前数为a，将a分解为质因数形式，注意每个质因数只被记录一次

例如：12=2*2*3 则 12会被分为2*3，多余的2被消去了

Step 4：将分出的素数进行组合，将组合出的a的约数的time+1

例如：12=2^2*3——>12=2*3——>time[2]++,time[3]++,time[6]++

Step 5：处理之后，ans赋值为C(n,4)即n*(n-1)*(n-2)*(n-3)div 24

Step 6：for i 2-->10000

if bool[i] then ans:=ans-C(time[i],4)

else ans:=and+C(time[i],4);

Step 7：输出ans

原理：首先考虑一个问题，1000以内6,7,8,9的倍数有多少个？答案是

1000div6+1000div7+1000div8+1000div9

-1000div(6*7)-1000div(6*8)-1000div(6*9)-1000div(7*8)-1000div(7*9)-1000div(8*9)

+1000div(6*7*8)+1000div(6*8*9)+1000div(7*8*9)

-1000div(6*7*8*9)

这是容斥原理的一个最简单的应用，类比这道题，Step3到4其实将每个数a的不重复约数记录了下来，有公共约数的四个数的方案要从ans中减去，多减的要加上

显然m为奇时要减，m为偶时要加，这和”1000以内6,7,8,9的倍数有多少个？“这个问题奇偶是反的，由于a最大为10000，所以m最大可以有5 (2*3*5*7*11<10000,2*3*5*7*11*13>10000)

至于12=2*2*3这种约数不处理因为可以分为2*6，而2和6会算一次，所以不须再算。

代码：

1 # include
2 # include
3 # include
4 # include
5 using namespace std;
6 int pa[2000],pp=0,sa[10],sp=0;
7 int refer[5][10001];
8 void make_prime()
9 {
10     bool used[10001];
11     memset(used,true,sizeof(used));
12     for(int i=2;i<=10000;i++)
13          if(used[i])
14          {
15              pa[pp++]=i;
16              for(int j=2*i;j<=10000;j+=i)
17                 used[j]=false;
18          }
19 }
20 void spilt(int n)
21 {
22     sp=0;
23     for(int i=0;i24         if(n%pa[i]==0)
25         {
26             sa[sp++]=pa[i];
27             while(n%pa[i]==0)
28                 n/=pa[i];
29         }
30 }
31 void putmap(int n)
32 {
33     spilt(n);
34     for(int i=1;i<(1<35     {
36         int n1=0,n2=1;
37         for(int j=0;j<5;j++)
38             if(i&(1<39                 n1++,n2*=sa[j];
40         refer[n1-1][n2]++;
41     }
42 }
43 long long c(int n)
44 {
45     return (long long)n*(n-1)*(n-2)*(n-3)/4/3/2;
46 }
47 long long getans(int n)
48 {
49     long long ans=c(n);
50     for(int i=0;i<5;i++)
51     {
52         bool flag=false;
53         for(int j=1;j<=10000;j++)
54             if(refer[i][j]>=4)
55                 flag=true,
56                 ans+=c(refer[i][j])*(i%2?1ll:-1ll);
57         if(!flag)break;
58     }
59     return ans;
60 }
61 int main()
62 {
63     int n;
64     make_prime();
65     while(scanf("%d",&n)!=EOF)
66     {
67         memset(refer,0,sizeof(refer));
68         for(int i=0;i69         {
70             int t;
71             scanf("%d",&t);
72             putmap(t);
73         }
74         printf("%lld\n",getans(n));
75     }
76     return 0;
77 }

yzhw 2012-02-17 02:03 发表评论

HDU 3682 To Be an Dream Architect 容斥原理

yzhw — Sun, 02 Oct 2011 16:06:00 GMT

题意；
每次可以删除一个木条x=?,y=?或者x=?,z=?或者y=?,z=?，求最后删除的木块总数
：
开始写的时候出现个BUG，无奈，上网找题解，更无奈，都是些几句话hash然后就是一堆难懂的代码。。
后来仔细想了想，把重复的操作去除后（就是两次删除的同一个木条），下面就是个很简单的容斥原理了
因为去除了重复操作，一个木块最多被删除3次，然后删除的个数就为被删除至少一次的个数-删除至少两次的个数+删除至少3次的个数。不能强行枚举，可以用map或者传说中的hash记录被删除掉木块的次数。这里，由于操作最多m=1000，删除木块数最多为C(m,2)，然后两两枚举操作，把相交木块删除次数+1，然后最后map中所有木块删除次数只能有2个值：1和3，当值为1时，total-1,值为3时，total-2
为什么？因为我说了，一个木块最多被删除3次，然后俩俩枚举的时候，你懂的。

1 # include <cstdio>
2 # include <utility>
3 # include <cstring>
4 # include <algorithm>
5 # include <functional>
6 # include <set>
7 # include <cstdlib>
8 # include <map>
9 using namespace std;
10 struct node
11 {
12     int p[3];
13     bool operator<(const node &pos) const
14     {
15         for(int i=0;i<3;i++)
16             if(p[i]!=pos.p[i])
17                 return p[i]<pos.p[i];
18         return false;
19     }
20 };
21 pair<int,int> data[1000][2];
22 set<pair<pair<int,int>,pair<int,int> > > r1;
23 map<node,int> r2;
24 int main()
25 {
26     int test;
27     scanf("%d",&test);
28     while(test--)
29     {
30        int n,m,p=0;
31        char str[128];
32        scanf("%d%d",&n,&m);
33        r1.clear();r2.clear();
34        while(m--)
35        {
36            scanf("%s",str);
37            char *t=strtok(str,",");
38            data[p][0].first=(*t)-'X';
39            data[p][0].second=atoi(t+2);
40            t=strtok(NULL," ");
41            data[p][1].first=(*t)-'X';
42            data[p][1].second=atoi(t+2);
43            if(data[p][0].first>data[p][1].first) swap(data[p][0],data[p][1]);
44            pair< pair<int,int>,pair<int,int> > tt;
45            tt.first=data[p][0];
46            tt.second=data[p][1];
47            if(data[p][0].second>=1&&data[p][0].second<=n&&data[p][1].second>=1&&data[p][1].second<=n&&r1.find(tt)==r1.end()) p++,r1.insert(tt);
48        }
49        m=p;
50        for(int i=0;i<m;i++)
51         for(int j=i+1;j<m;j++)
52           if(data[i][0]==data[j][0]&&data[i][1].first!=data[j][1].first||
53              data[i][1]==data[j][0]&&data[i][0].first!=data[j][1].first||
54              data[i][0]==data[j][1]&&data[i][1].first!=data[j][0].first||
55              data[i][1]==data[j][1]&&data[i][0].first!=data[j][0].first)
56           {
57               node t;
58               t.p[data[i][0].first]=data[i][0].second;
59               t.p[data[i][1].first]=data[i][1].second;
60               t.p[data[j][0].first]=data[j][0].second;
61               t.p[data[j][1].first]=data[j][1].second;
62               r2[t]++;
63           }
64        int total=m*n;
65        for(map<node,int>::iterator i=r2.begin();i!=r2.end();i++)
66            if(i->second==1) total--;
67            else total-=2;
68        printf("%d\n",total);
69     }
70     //system("pause");
71     return 0;
72 }
73

yzhw 2011-10-03 00:06 发表评论

pku 1222 EXTENDED LIGHTS OUT 高斯消元

yzhw — Sat, 15 Jan 2011 17:35:00 GMT

题意：
一个5*6的开关矩阵，拨动每个开关，都会使得它本身以及前后左右四个开关反转。现在给出所有开关的初始状态，问使得所有开关处于关状态，需要拨动的开关。

解法：
首先看到这题就应该想到方程组。或者说，是一个模2方程组。
但是，这个会给我们带来求解的麻烦。求解方程组有经典的高斯消元法，但是出现模运算，确实让人头疼。这里，我们想到了异或运算，联系高斯消元的本质，是用一个方程来代换另外一个方程，十进制模二运算中的加、减运算与二进制中的异或运算正好对应！然后下面的事情就简单多了

有一个小技巧，使用位运算能够大大简化编程复杂度。
可以将原来矩阵的每一行压缩成一个32位整数，这样每次消元的过程中选择列主元的过程可以用排序轻松解决~，然后消去的过程和回代的过程也就非常好实现了。用这种方法，这题的代码量可以控制在60行以内。
忽然想起了老队长说过的话:100行以内的程序才是正解，做了这么多题，越来越发现这句话是多么的经典。话说现在郭老大在马化腾那应该算个红人了~

还有件很囧的事，使用STL里的greater仿函数竟然要包括一个叫functional的头文件，甚是诡异。。

代码:

1 # include <cstdio>
2 # include <algorithm>
3 # include <functional>
4 # include <cstring>
5 using namespace std;
6 inline void setbit(int &num,int bit)
7 {
8     num|=1<<(30-bit);
9 }
10 inline bool getbit(int &num,int bit)
11 {
12     if(num&(1<<(30-bit))) return true;
13     else return false;
14 }
15 int main()
16 {
17     int test;
18     scanf("%d",&test);
19     for(int t=1;t<=test;t++)
20     {
21         int e[30];
22         memset(e,0,sizeof(e));
23         for(int i=0;i<30;i++)
24         {
25             int tmp;
26             scanf("%d",&tmp);
27             setbit(e[i],i);
28             if(i%6!=0) setbit(e[i],i-1);
29             if(i%6!=5) setbit(e[i],i+1);
30             if(i/6!=0) setbit(e[i],i-6);
31             if(i/6!=4) setbit(e[i],i+6);
32             if(tmp) setbit(e[i],30);
33         }
34         for(int i=0;i<30;i++)//消元
35         {
36             sort(e+i,e+30,greater<int>());
37             if(getbit(e[i],i))
38                 for(int j=i+1;j<30;j++)
39                     if(getbit(e[j],i))
40                         e[j]^=e[i];
41
42         }
43         for(int i=29;i>=0;i--)//回代
44             if(getbit(e[i],i))
45               for(int j=i-1;j>=0;j--)
46                   if(getbit(e[j],i))
47                       e[j]^=e[i];
48         printf("PUZZLE #%d\n",t);
49         for(int i=0;i<30;i++)
50         {
51            if(e[i])
52              printf("%d",getbit(e[i],30));
53            else printf("0");
54            if(i%6==5) printf("\n");
55            else printf(" ");
56         }
57     }
58     return 0;
59 }

yzhw 2011-01-16 01:35 发表评论

pku1217 FOUR QUARTERS 概率递推

yzhw — Sat, 06 Nov 2010 11:52:00 GMT

题意：
A、B俩游戏者，每轮俩人分别抛俩硬币，然后根据结果结算该轮得分：

A胜B即A的点数大于B的点数。
然后输出20轮内A赢B、B赢A以及打平的概率。

解答：
这题和一般的概率题不同，二者的点数是不独立的，所以要用一个pair和map存储他们的概率。
结合代码来说吧

1 # include <cstdio>
2 # include <cstring>
3 using namespace std;
4 # include <map>
5 # define encode(a,b) (((a)<<6)|(b))
6 # define getp1(a) ((a)>>6)
7 # define getp2(a) ((a)&63)
8 int main()
9 {
10     double res[21][2];
11     //p[i][j]，A得到i-1分，B得到j-1分的概率，以后为了处理方便，可以将得-1,0,1,2分看作得0,1,2,3分
12     double p[4][4]={{0,0,0,1.0/16},{1.0/16,3.0/8,1.0/8,0},{1.0/8,3.0/16,0,0},{1.0/16,0,0,0}};
13     memset(res,0,sizeof(res));
14     map<int,double> table[21];
15     table[0][encode(0,0)]=1.0;//边界情况：A得0分，B得0分的概率为1
16     for(int step=1;step<=21;step++)
17     {
18         for(map<int,double>::iterator ita=table[step-1].begin();ita!=table[step-1].end();ita++)
19         {
20             int p1=getp1(ita->first),p2=getp2(ita->first);
21             if(step!=21)
22             {
23
24                 for(int i=0;i<4;i++)
25                     for(int j=0;j<4;j++)
26                         table[step][encode(p1+i,p2+j)]+=(ita->second)*p[i][j];//状态转移
27             }
28             if(p1<p2)//累加A输给B的概率
29                 res[step-1][0]+=ita->second;
30             else if(p1==p2)//累加打平的概率
31                 res[step-1][1]+=ita->second;
32         }
33     }
34     printf("Round   A wins    B wins    Tie\n");
35     for(int i=1;i<=20;i++)//输出格式注意,如果需要在printf内输出%的话要用%%
36         printf("%5d%10.4f%%%9.4f%%%9.4f%%\n",i,(1-res[i][0]-res[i][1])*100,res[i][0]*100,res[i][1]*100);
37     return 0;
38 }
39

yzhw 2010-11-06 19:52 发表评论

pku2151 Check the difficulty of problems 概率DP，可恶的StreamTokenizer!!!!!

yzhw — Mon, 01 Nov 2010 17:23:00 GMT

好吧，这道题思想开始就想到了，结果做的搓死了。。
题意是这样，ACM比赛，T个队，M个题，第i个队做出第j个题的概率为p_i,j，求所有队至少做一题并且冠军队（可能有多个队）做出N题以上的概率
首先，每个队是独立的。
设dp[i][j]为前i个题目做出j题的概率，有dp方程dp[i][j]=dp[i-1][j-1]*(p[pos][i])+dp[i-1][j]*(1-p[pos][i])
边界条件：dp[0][0]=0;dp[i][0]=dp[i-1][0]*(1-p[pos][i])
然后结果应该是每队至少做出一题的概率减去在这个基础上所有队做题数小于N的概率。
万恶的StreamTokenizer，不知道读入数据的时候出了什么诡异的问题，对照标程对拍，就是没错误，一提交就WA！最后换Scanner，顺利AC。。无语。
比赛的时候知道了，数据比较大或者浮点的情况下还是别用StreamTokenizer了。。

1import java.io.*;
2import java.text.DecimalFormat;
3import java.util.Arrays;
4import java.util.Scanner;
5public class Main {
6
7    /**
8     * @param args
9     */
10
11    static double dp[][]=new double[35][35],map[][]=new double[1001][31];
12    static int m,t,n;
13    public static void main(String[] args) throws Exception{
14        Scanner in=new Scanner(System.in);
15        while(true)
16        {
17            m=in.nextInt();t=in.nextInt();n=in.nextInt();
18            if(m==0&&t==0&&n==0) break;
19            for(int i=1;i<=t;i++)
20                for(int j=1;j<=m;j++)
21                    map[i][j]=in.nextDouble();
22            double total=1.0,minus=1.0;
23            for(int i=1;i<=t;i++)
24            {
25                for(int j=0;j<=m;j++)
26                    Arrays.fill(dp[j],0.0);
27                double t1=0.0,t2=0.0;
28                dp[0][0]=1.0;
29                for(int j=1;j<=m;j++)
30                {
31                    dp[j][0]=dp[j-1][0]*(1-map[i][j]);
32                    for(int k=1;k<=m;k++)
33                        dp[j][k]=dp[j-1][k-1]*map[i][j]+dp[j-1][k]*(1-map[i][j]);
34                }
35                for(int j=1;j<=m;j++)
36                {
37                    t1+=dp[m][j];
38                    t2+=(j<n?dp[m][j]:0);
39                }
40
41                total*=t1;
42                minus*=t2;
43            }
44            System.out.printf("%.3f\n",total-minus);
45        }
46
47    }
48
49}
50

yzhw 2010-11-02 01:23 发表评论

pku1920 Towers of Hanoi 河内塔问题

yzhw — Sun, 31 Oct 2010 18:31:00 GMT

给出河内塔的中间状态，求将所有盘子摞到一起的的最小步数。
先贴程序

1 import java.util.*;
2 import java.io.*;
3 public class Main {
4
5     /**
6      * @param args
7      */
8     static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
9     static final int nextInt() throws Exception
10     {
11         in.nextToken();
12         return (int)in.nval;
13     }
14     public static void main(String[] args) throws Exception{
15
16         int num=nextInt();
17         int step[]=new int[num+1];
18         int id[]=new int[num+1];
19         step[1]=1;
20         for(int i=2;i<=num;i++)
21             step[i]= (step[i-1]<<1)%1000000;
22         ArrayList<Integer> data[]=new ArrayList[3];
23         for(int i=0;i<3;i++)
24             data[i]=new ArrayList<Integer>();
25         int a=nextInt(),b=nextInt(),c=nextInt();
26         while((a--)!=0)
27             id[nextInt()]=0;
28         while((b--)!=0)
29             id[nextInt()]=1;
30         while((c--)!=0)
31             id[nextInt()]=2;
32         int s=id[num],e=s,mid=0,total=0;
33         for(int i=num;i>=1;)
34         {
35             if(s!=e)
36             {
37                 total=(step[i]+total)%1000000;
38                 e=mid;
39             }
40             s=id[--i];
41             mid=3-s-e;
42         }
43         System.out.println(id[num]+1);
44         System.out.println(total);
45
46
47
48     }
49
50 }
51

yzhw 2010-11-01 02:31 发表评论

pku 1737 Connected Graph 组合数学，图的计数问题注意联系连通分量

yzhw — Wed, 27 Oct 2010 15:47:00 GMT

题目意思很明了，计算一个n个顶点的无向连通图的数量
可以这样思考:
n个顶点的无相连通图构成方法为在n-1个节点中分离出一个大小为i的联通分量加上第n个节点与剩余的n-1-i个点构成的联通分量（可能n-1-i个点并不联通，但是可以通过第n个点联通），所以初步的式子是这样：
dp[i]=sum{dp[j]*(1 shl j-1)*dp[i-j]*c[j-1][i]}
但是这个式子有点问题，会产生重复，如图所示

1）

2）

1）和2）其实是同一种状态，但是按算选出（1，2）是一种，选出（3，4）是一种，所以产生了重复。

那么该怎么修改呢，其实只要固定一个点，假设是1，再从n-1个点中选出i-1个点去跟1构成连通图即C^i-1_n-1，那样就可以避免重复了；

所以式子修正为

dp[i]=sum{dp[j]*(1 shl j-1)*dp[i-j]*c[j-2][i-1]}
不知道网上很多人为什么要从反面考虑，即算出n无向图的个数2^C[n][2]然后再减去不连通的诱导子图数目，感觉是多此一举~

1 import java.io.*;
2 import java.math.*;
3 public class Main {
4
5     /**
6      * @param args
7      */
8     public static void main(String[] args) throws IOException{
9         BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
10         BigInteger dp[]=new BigInteger[60];
11         BigInteger c[][]=new BigInteger[51][51];
12         c[0][0]=BigInteger.ONE;
13         for(int i=1;i<=50;i++)
14             c[i][0]=c[i][i]=BigInteger.ONE;
15         for(int i=2;i<=50;i++)
16             for(int j=1;j<i;j++)
17                 c[i][j]=c[i-1][j].add(c[i-1][j-1]);
18         dp[1]=BigInteger.ONE;
19         dp[0]=BigInteger.ONE;
20         for(int i=2;i<=50;i++)
21         {
22             dp[i]=BigInteger.ZERO;
23             for(int j=1;j<i;j++)
24                 dp[i]=dp[i].add(dp[j].multiply((BigInteger.ONE.shiftLeft(j)).add(BigInteger.ONE.negate())).multiply(dp[i-j]).multiply(c[i-2][j-1]));
25         }
26         int num=0;
27         while(true)
28         {
29             num=Integer.parseInt(in.readLine());
30             if(num==0) break;
31             System.out.println(dp[num]);
32         }
33
34     }
35
36 }
37

yzhw 2010-10-27 23:47 发表评论