C++博客-ickchen2-文章分类-zoj月赛

zoj 3405 Counting Factor Trees

神之子 — Tue, 07 Sep 2010 14:17:00 GMT

明显是一道水题，但确不会做
如果把数给分解了之后有n个质因子。那么就是求n个点可以有多少种二叉树，然后把这n个质因子放进去就行了
求多少种二叉树就是dp，放质因子就是一个可重排列数

  1 #include<stdio.h>
  2 #include<iostream>
  3 #include<string>
  4 #include<vector>
  5 #include<map>
  6 #include<queue>
  7 #include<algorithm>
  8 #define M 1000
  9 #define clr(x) memset(x,0,sizeof(x))
10 #define _clr(x) memset(x,-1,sizeof(x))
11 #define fr(i,a,b) for(int i=a;i
12 #define pf printf
13 #define sf scanf
14 #define pb push_back
15 #define mp make_pair
16 #define ll long long
17 #define debug 1
18 using namespace std;
19 const int maxs=1000000;
20 int pr[1000000],is[maxs+10],len;
21 int e[1000000],cnt;
22 void Frac(ll n)
23 {
24     cnt=0;
25     fr(i,0,len)
26     {
27         if((ll)pr[i]*pr[i]>n)break;
28         //pf("pr=%d\n",pr[i]);
29         if(n%pr[i]==0)
30         {
31             e[cnt]=0;
32             while(n%pr[i]==0)
33             {
34                 n/=pr[i];
35                 ++e[cnt];
36             }
37             ++cnt;
38         }
39     }
40     if(n>1)
41     {
42         e[cnt++]=1;
43     }
44 }
45 void getPrime()
46 {
47     len=0;
48     clr(is);
49     for(int i=2;i<maxs;++i)
50     {
51         if(!is[i])
52         {
53             pr[len++]=i;
54         }
55         for(int j=0;j<len&&(ll)pr[j]*i<maxs;++j)
56         {
57             is[pr[j]*i]=1;
58             if(i%pr[j]==0)break;
59         }
60     }
61 }
62 int p[1000000],exp[1000000],c;
63 ll pow(int a,int b)
64 {
65     ll ret=1;
66     while(b>0)
67     {
68         if(b&1){ret*=a;}
69         a*=(ll)a;
70         b>>=1;
71     }
72     return ret;
73 }
74 ll cal()
75 {
76     int tot=0;
77     for(int i=0;i<cnt;++i)
78     {
79         tot+=e[i];
80     }
81     //pf("c:\n");
82     //pf("tot=%d\n",tot);
83     c=0;
84     for(int i=0;i<len;++i)
85     {
86         if(pr[i]>tot)break;
87         p[c]=pr[i];
88         exp[c]=0;
89         int tem=tot;
90         while(tem>0)
91         {
92             exp[c]+=tem/p[c];
93             tem/=p[c];
94         }
95        // pf("pc=%d expc=%d\n",p[c],exp[c]);
96         ++c;
97     }
98     for(int i=0;i<cnt;++i)
99     {
100         int ret=e[i];
101         for(int j=0;j<len;++j)
102         {
103             if(pr[j]>ret)break;
104             int pos=lower_bound(p,p+c,pr[j])-p;
105             int tem=ret;
106             while(tem>0)
107             {
108                 exp[pos]-=tem/pr[j];
109                 tem/=pr[j];
110             }
111         }
112     }
113     ll res=1;
114     for(int i=0;i<c;++i)
115     {
116         res*=pow(p[i],exp[i]);
117     }
118     return res;
119 }
120 ll dp[1000000];
121 ll dfs(int n)
122 {
123    // if(n>1000000)return 1;
124     if(dp[n])return dp[n];
125     ll ret=0;
126     for(int i=1;i<=n/2;++i)
127     {
128         ll tem=dfs(i)*dfs(n-i);
129         if(i!=n-i)tem*=2;
130         ret+=tem;
131     }
132     return dp[n]=max(ret,(ll)1);
133 }
134
135 int main()
136 {
137
138     int n;
139     getPrime();
140     clr(dp);
141     freopen("in.txt","r",stdin);
142     //freopen("out1.txt","w",stdout);
143     while(sf("%d",&n)>0)
144     {
145         //ft.clear();
146         Frac(n);
147         int tot=0;
148         fr(i,0,cnt)
149             tot+=e[i];
150         //pf("tot=%d\n",tot);
151         ll ans=dfs(tot);
152         ans*=cal();
153         pf("%lld\n",ans);
154     }
155
156     return 0;
157 }
158

神之子 2010-09-07 22:17 发表评论

zoj 3404 Sticker

神之子 — Tue, 07 Sep 2010 14:14:00 GMT

问一个n长度的数有多少种可以利用某些转换转换成只有1到N的数。可以把能用A换B的变成从A连向B的一条边
由于题目说明每个点的出度和入度不大于1。因此图中只有两种情况，一个是链，一个是环。链的话，如果长度是M，就表示从长度为k的未放置格中取出m个位置来放置这m个数。而因此链上的点可以向下转换，因此可以用DP来解决dp[i,j]表示第i个点占用了j个位置的方案数dp[i,j]=sum(dp[i-1][k]*c[j][k])。环也一样，不过链要求I各点最多只能放I个位置，不然链头的某些点就不能从某些点得到了。环就无此限制
最后扫描一下图，统计一下就行了

  1 #include<stdio.h>
  2 #include<iostream>
  3 #include<string>
  4 #include<vector>
  5 #include<map>
  6 #include<queue>
  7 #include<algorithm>
  8 #define M 1000
  9 #define clr(x) memset(x,0,sizeof(x))
10 #define _clr(x) memset(x,-1,sizeof(x))
11 #define fr(i,a,b) for(int i=a;i
12 #define pf printf
13 #define sf scanf
14 #define pb push_back
15 #define mp make_pair
16 #define ll long long
17 #define debug 1
18 using namespace std;
19 const ll mod=(ll)1000000007;
20 ll dp1[201][201],dp2[201];
21 ll c[201][201];
22 ll pow(int a,int b)
23 {
24     ll ret=1;
25     while(b>0)
26     {
27         if(b&1){ret=(ret*a)%mod;}
28         a=((ll)a*a)%mod;
29         b>>=1;
30     }
31     return ret;
32 }
33 void init()
34 {
35     clr(c);
36     c[0][0]=1;
37     fr(i,1,201)
38     {
39         c[i][0]=1;
40         fr(j,1,i+1)
41         {
42             c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
43         }
44     }
45     clr(dp1);
46     dp1[0][0]=1;
47     //链DP
48     fr(i,1,201)
49     {
50
51         fr(j,0,i+1)
52         {
53             //链上第i个节点用了j个位置
54             fr(k,0,j+1)
55                 dp1[i][j]=(dp1[i][j]+dp1[i-1][k]*c[j][j-k])%mod;
56         }
57     }
58     //环
59     fr(i,1,201)
60     {
61         dp2[i]=pow(i,i);
62     }
63 }
64 int to[201];
65 int v[201];
66 int s[201];
67 vector<int>h,l;
68 vector< pair<int,int> >ft;
69 int main()
70 {
71     freopen("in.txt","r",stdin);
72     init();
73     int T;
74     sf("%d",&T);
75     while(T--)
76     {
77         int n,m;
78         sf("%d%d",&n,&m);
79         _clr(to);
80         clr(v);
81         _clr(s);
82         fr(i,0,m)
83         {
84             int a,b;
85             sf("%d%d",&a,&b);
86             to[a]=b;
87             s[b]=a;
88         }
89         int pos=n;
90         ll ans=1;
91         fr(i,0,n)
92         {
93             if(v[i])continue;
94             int now=i;
95             int count=0;
96             while(now!=-1&&!v[now])
97             {
98                 v[now]=1;
99                 ++count;
100                 //if(to[now]==-1)break;
101                 now=to[now];
102             }
103             if(now!=-1)
104             {
105                // pf("cc=%d\n",count);
106                 ans=(ans*c[pos][count])%mod;
107                 ans=(ans*dp2[count])%mod;
108                 pos-=count;
109             }
110             else
111             {
112                 now=s[i];
113                 while(now!=-1)
114                 {
115                     //pf("now=%d\n",now);
116                     v[now]=1;
117                     now=s[now];
118                     ++count;
119                 }
120                 //pf("c=%d\n",count);
121                 ans=(ans*c[pos][count])%mod;
122                 ans=(ans*dp1[count][count])%mod;
123                 pos-=count;
124             }
125         }
126         pf("%lld\n",ans);
127     }
128     return 0;
129 }
130

神之子 2010-09-07 22:14 发表评论

zoj 3399 Classes Division

神之子 — Tue, 07 Sep 2010 14:08:00 GMT

这题很明显的是DP，DP方程很容易就想到为dp[i,j]=min(dp[k][j-1]+(sum[i]-sum[k])*g[j]）（n-b<=k但普通转移必定挂。
如果把方程变一变dp[i,j]=sum[i]*g[j]+min(dp[k][j-1]-sum[k]*g[j])
这样在如果j不变的情况下，后面的最小值是不变的。因此可以O(1)的转移
但由于存在范围，因此可以利用堆或者单调队列来处理

  1 #include<stdio.h>
  2 #include<iostream>
  3 #include<string>
  4 #include<vector>
  5 #include<map>
  6 #include<queue>
  7 #include<algorithm>
  8 #define M 1000
  9 #define clr(x) memset(x,0,sizeof(x))
10 #define _clr(x) memset(x,-1,sizeof(x))
11 #define fr(i,a,b) for( i=a;i
12 #define pf printf
13 #define sf scanf
14 #define pb push_back
15 #define mp make_pair
16 #define ll long long
17 #define debug 1
18 using namespace std;
19 const ll oo=100000000000000ll;
20 ll dp[205][10005];
21 int x[11000],g[210];
22 ll sum[11000];
23 ll L;
24 int n,k,A,B;
25 inline
26 ll sqr(ll x)
27 {
28     return (ll)x*x;
29 }
30 void init()
31 {
32     int i;
33     L=0;
34     fr(i,1,n+1)
35     {
36         L+=x[i];
37     }
38     L=L/n;
39     sum[0]=0;
40     fr(i,1,n+1)
41     {
42         sum[i]=sum[i-1]+sqr(x[i]-L);
43     }
44 }
45 int l,r;
46 struct node
47 {
48     ll t;
49     int pos;
50     node(){}
51     node(ll t,int pos):t(t),pos(pos){}
52 };
53 int operator <(const node &a,const node&b)
54 {
55     return a.t<b.t||a.t==b.t&&a.pos<b.pos;
56 }
57 const int queuesize=10005;
58 node q[queuesize];
59 inline
60 ll min(ll a,ll b)
61 {
62     return a<b?a:b;
63 }
64 void sol()
65 {
66     int i,j;
67     fr(i,0,k+1)
68     {
69         fr(j,0,n+1)
70             dp[i][j]=oo;
71     }
72     dp[0][0]=0;
73     ll ans=-1;
74     int cl=k+1,T=n+1;
75     fr(i,1,k+1)
76     {
77         l=0,r=0;
78         fr(j,A,n+1)
79         {
80             if(dp[i-1][j-A]!=oo)
81             {
82                 node tem=node(dp[i-1][j-A]-sum[j-A]*g[i],j-A);
83                 while(l<r&&q[r-1].t>=tem.t)--r;
84                 q[r++]=tem;
85             }
86
87             while(l<r&&q[l].pos<j-B)++l;
88             if(l==r)continue;
89             dp[i][j]=q[l].t+sum[j]*g[i];
90         }
91         if(dp[i][n]!=oo)
92         {
93             if(ans==-1||ans>dp[i][n])
94             {
95                 ans=dp[i][n];
96                 cl=i;
97                 T=n-q[l].pos;
98             }
99         }
100     }
101     if(ans!=-1)
102         pf("%lld %d %d\n",ans,cl,T);
103     else
104         pf("No solution.\n");
105 }
106 int main()
107 {
108     freopen("in.txt","r",stdin);
109     int i;
110     int ca=0;
111     while(sf("%d%d%d%d",&n,&k,&A,&B)>0)
112     {
113         //if(ca++)pf("\n");
114         fr(i,1,n+1)
115         {
116             sf("%d",&x[i]);
117         }
118         fr(i,1,k+1)
119         {
120             sf("%d",&g[i]);
121         }
122         init();
123         sol();
124     }
125     return 0;
126 }
127

神之子 2010-09-07 22:08 发表评论

zoj 3397 Change the Major

神之子 — Tue, 07 Sep 2010 14:04:00 GMT

这个是汉诺塔的变形，思想和汉诺塔一样
但有一个很重要的是某两个点不能直接去，要经过第三个点，如果没用这种情况，递归方程很容易就写出来的。

在递归中，用s,t表示当前点从哪个点出发，到哪个点。如果S=-1，表示刚开始处理的点，如果T=-1，表示下面的点已经处理好了，这个点的目标任意（那肯定是要去自己想去的地方啦:) ）因此如果S,T都不为-1的话，就表示是在移动的过程中，这个点的移动只是为了让下面的点移动。因此可以将这个点以上的点看作是一条柱子来处理。计算出N个点一起从某个点到某个点移动的最小次数。

  1 #include<stdio.h>
  2 #include<iostream>
  3 #include<string>
  4 #include<vector>
  5 #include<map>
  6 #include<queue>
  7 #include<algorithm>
  8 #define M 1000
  9 #define clr(x) memset(x,0,sizeof(x))
10 #define _clr(x) memset(x,-1,sizeof(x))
11 #define fr(i,a,b) for(int i=a;i
12 #define pf printf
13 #define sf scanf
14 #define pb push_back
15 #define mp make_pair
16 #define ll long long
17 #define debug 1
18 using namespace std;
19 int n;
20 struct person
21 {
22     int po,pt,p;
23     bool operator<(const person &a)const
24     {
25         return p<a.p;
26     }
27 }p[20];
28
29 ll dp[20][3][3];
30 int dfs1(int n,int s,int t)
31 {
32     if(dp[n][s][t])return dp[n][s][t];
33     if(n<=0)return 0;
34     if(n==1)
35     {
36         if(s+t==2)
37             return dp[n][s][t]=2;
38         else
39             dp[n][s][t]=1;
40     }
41     //return 1;
42     if(s+t==2)
43     {
44         return dp[n][s][t]=3*dfs1(n-1,s,t)+2;
45     }
46     return dp[n][s][t]=dfs1(n-1,s,3-s-t)+1+dfs1(n-1,3-s-t,t);
47 }
48 ll dfs(int cur,int s,int t)
49 {
50     if(cur==n)return 0;
51     int ss,tt;
52     if(s!=-1&&t!=-1)
53     {
54         //一栋的东西从某一个位置移到某一个位置
55         if(s==t)
56         {
57             ll tem=dfs(cur+1,s,t);
58             return tem;
59         }
60         else
61         {
62             ll tem=dfs1(n-cur,s,t);
63             return tem;
64         }
65     }
66     if(s==-1)ss=p[cur].po;
67     else ss=s;
68     if(t==-1)tt=p[cur].pt;
69     else tt=t;
70     if(ss==tt)
71     {
72         ll tem=dfs(cur+1,s,t);
73         return tem;
74     }
75     if(ss+tt==2)
76     {
77         ll tem=dfs(cur+1,s,tt)+1+dfs(cur+1,tt,ss)+1+dfs(cur+1,ss,t);;
78         return tem;
79     }
80
81
82         ll tem=dfs(cur+1,s,3-ss-tt)+1+dfs(cur+1,3-ss-tt,t);
83         return tem;
84
85 }
86 string s[2];
87 int getM(int pos)
88 {
89     if(s[pos][0]=='C')
90     {
91         if(s[pos][1]=='o')
92             return 0;
93         return 1;
94     }
95     return 2;
96 }
97 int main()
98 {
99     freopen("in.txt","r",stdin);
100     clr(dp);
101     while(sf("%d",&n)>0)
102     {
103         fr(i,0,n)
104         {
105             string point;
106             cin>>s[0]>>s[1]>>point;
107             p[i].po=getM(0);
108             p[i].pt=getM(1);
109             int a,b;
110             sscanf(point.c_str(),"%d.%d",&a,&b);
111             p[i].p=a*100+b;
112             //pf("po=%d pt=%d p=%d\n",po[i],pt[i],p[i]);
113         }
114         sort(p,p+n);
115         pf("%lld\n",dfs(0,-1,-1));
116     }
117     return 0;
118 }
119

神之子 2010-09-07 22:04 发表评论

zoj 3396 Conference Call

神之子 — Tue, 07 Sep 2010 13:57:00 GMT

题目是说给出一个图，问包含其中3点的最小生成子树
由于只有3个点，因此肯定有一个支撑点，就是3个点相互到达时必定经过的点，因此只要我们枚举这个点计算3个点离这个点的距离，然后取最小值的点就行了
一开始脑残了，以为这个支撑点就是这3个点的某个。

神之子 2010-09-07 21:57 发表评论