SRM 601 DIV1

A

　　枚举x , 然后对于确定的x , 最后总的apple数对应了唯一的orange数,因此问题转化为求apple的取值范围;

　　apple的取值范围: max为每个bag取最多的apple , min为每个bag取最小的apple , 容易证明[min,max]是连续的.

　　

 using namespace std;

 class WinterAndPresents {
 public:
     long long getNumber(vector <int>, vector <int>);
 };
 struct node {
     int a,o;
 };vector<node> f;
 bool cmp(node x,node y) {
     if (x.a==y.a) return x.o<y.o;
     return x.a<y.a;
 }
 long long WinterAndPresents::getNumber(vector <int> apple, vector <int> orange) {
     long long ans = ;
     int x = -,n = apple.size();
     for (int i= ; i<n ; i++ ) {
         if (x==- || x>apple[i]+orange[i]) x=apple[i]+orange[i];
         f.push_back((node){apple[i],orange[i]});
     }
     for (int i= ; i<=x ; i++ ) {
         long long big =  , sml = ;
         for (int j= ; j<n ; j++ ) {
             if (f[j].a>=i) big += i;
             else big += f[j].a;

             if (f[j].o>=i) sml += ;
             else sml += i-f[j].o;
         }
         ans += big-sml+;
     }
     return ans;
 }

B

　　关键在于优化dp状态.

　　朴素的dp是: dp[i][mask1][mask2]  在考虑第i个数时 集合1的状态为mask1 , 集合2的状态为mask2.

　　为了优化掉一维,应该考虑把状态设计成 dp[i][mask1^mask2] , 然后为了识别大小再用1维记录最高非0位属于哪个集合,

　　再换个角度来看,可以枚举最后最高非0位在位置p , 然后用dp[i][mask1^mask2][0/1]表示:

　　　　选择了i个 ; 集合1,2的异或值异或为mask1^mask2 ; mask1在p位置是0/1

　　就把原来的 O(maxn*mask1*mask2) 复杂度优化为O(maxn*mask1*2*log(maxn))

　　最后,在实现的时候可以把 (mask1^mask2) 右移p位 , 因为最高非零位之后的都无关紧要, 此时的状态数变更小了,用dfs实现可以更快.

 #include <vector>
 #include <list>
 #include <map>
 #include <set>
 #include <deque>
 #include <stack>
 #include <bitset>
 #include <algorithm>
 #include <functional>
 #include <numeric>
 #include <utility>
 #include <sstream>
 #include <iostream>
 #include <iomanip>
 #include <cstdio>
 #include <cmath>
 #include <cstdlib>
 #include <ctime>
 #include <cstring>
 using namespace std;
 #define mod 1000000007
 class WinterAndSnowmen {
 public:
     int getNumber(int, int);
 };
 int dp[][<<][],p,n,m;
 int dfs(int t,int sum,int b) {
     //printf("t:%d sum:%d b:%d\n",t,sum,b);
     if (t==) {
     //    printf("p:%d sum:%d b:%d\n",p,sum,b);
         if ( sum== && b== ) return ;
         else return ;
     }
     if (dp[t][sum][b]!=-) return dp[t][sum][b];
     else {
         long long res = ;
         if (t<=n) {
             res += dfs( t- , sum^(t>>p) , b^((t>>p)&) );
         }
         if (t<=m) {
             res += dfs(t- , sum^(t>>p) , b );
         }
         res += dfs( t- , sum , b );
         res %= mod;
         return dp[t][sum][b]=(int)res;
     }
 }
 int WinterAndSnowmen::getNumber(int N, int M) {
     int res = ;
     n = N , m = M;
     for (int i= ; i< ; i++ ) {
         memset(dp,-,sizeof(dp));
         p = i;
         res += dfs(max(N,M),,);
         res %= mod;
     //    printf("i:%d add:%d\n",i,tmp);
     }
     return res;
 }

 //Powered by [KawigiEdit] 2.0!

C

　　又是个需要状态优化的dp.

　　朴素的状态设计是: f(t , r0 , g0 , b0 , r1 , g1 , b1) , 表示第t天 , 第一个shop的销售情况和第二个shop的销售情况;

　　但是考虑到两个shop同时营业时 , 销售情况必须一致 , 当碰到有同时营业的情况时 , 可以直接跳到下一个结束点:

　　　　于是新的状态表示为 f(t,r0,g0,b0) ;

　　然后再通过各种判断,来知道如何转移;

　　进一步优化是去掉b0的记录, 因为每天必须售出一个ball ,  知道当前天t,开始天first,已经其它销售情况就能计算出b0.

　　最后的状态表示为f(t,r0,g0).

　　

 using namespace std;
 #define maxn 510
 #define mod 1000000007
 class WinterAndShopping {
 public:
     int getNumber(vector <int>, vector <int>, vector <int>, vector <int>);
 };

 struct node{
     int f,r,g,b;
     int end() {
         return f+r+g+b;
     }
 };vector<node> s[maxn];
 int dp[maxn][][],c[maxn][maxn];

 void pretreat(vector<int> f, vector<int> r, vector<int> g, vector<int> b) {
     for (int i= ; i<(int)f.size() ; i++ ) {
         for (int j=f[i] ; j<f[i]+r[i]+g[i]+b[i] ; j++ ) {
             s[j].push_back((node){f[i],r[i],g[i],b[i]});
         }
     }
     for (int i= ; i<maxn ; i++ ) if (s[i].size()==) {
         if (s[i][].f>s[i][].f) swap(s[i][],s[i][]);
     }
     for (int i= ; i<maxn ; i++ ) {
         c[i][] = ;
         for (int j= ; j<=i ; j++ )
             c[i][j] = (c[i-][j-] + c[i-][j]) % mod;
     }
 }

 long long getfct(int r,int g,int b) {
     long long res = (long long)c[r+g+b][r] * (long long )c[g+b][g] % mod;
 //    printf("r:%d g:%d b:%d res:%lld\n",r,g,b,res);
     return res;
 }

 long long dfs(int t,int r,int g) {
     if (t==) {
         if (r== && g==) return ;
         else return ;
     }
     if (dp[t][r][g]!=-) return (long long)dp[t][r][g];
     else {
         long long res = ;
         if (s[t].size()==) res = dfs(t+,,);
         else if (s[t].size()==) {
             if (t+ == s[t][].end()) res = dfs(t+,,);
             else {
                 if (r+<=s[t][].r) res += dfs(t+,r+,g);
                 if (g+<=s[t][].g) res += dfs(t+,r,g+);
                 if (t-s[t][].f-r-g+<=s[t][].b) res += dfs(t+,r,g);
             }
             res %= mod;
         }
         else if (s[t].size()==) {
             node s0 = s[t][] , s1 = s[t][];
             int b = (t-s0.f-(r+g));
             if (s0.end() == s1.end()) {
                 if (s0.r-r==s1.r && s0.g-g==s1.g && s0.b-b==s1.b) {
                     res = getfct(s1.r,s1.g,s1.b) * dfs(s1.end(),,) % mod;
                 }
             } else if (s0.end() < s1.end()) {
                 if (s0.r-r<=s1.r && s0.g-g<=s1.g && s0.b-b<=s1.b) {
                     res = getfct(s0.r-r,s0.g-g,s0.b-b) * dfs(s0.end(),s0.r-r,s0.g-g) % mod;
                 }
             } else if (s0.end() > s1.end()) {
                 if (s1.r<=s0.r-r && s1.g<=s0.g-g && s1.b<=s0.b-b) {
                     res = getfct(s1.r,s1.g,s1.b) * dfs(s1.end(),r+s1.r,g+s1.g) % mod;
                 }
             }
         }
         dp[t][r][g] = (int)res;
         return res;
     }
 }

 int WinterAndShopping::getNumber(vector <int> f, vector <int> r, vector <int> g, vector <int> b) {
     pretreat(f,r,g,b);
     memset(dp,-,sizeof(dp));
     long long ans = dfs(,,);
     return (int)ans;
 }