NOIP模拟·20141105题解

【A、韩信点兵】

结论题+模板题，用到了中国剩余定理，维基百科上讲的就比较详细，这里就不再赘述了……

对于这题，我们先利用中国剩余定理($x \equiv \sum{(a_i m_i (m_i^{-1} \mod p_i))}\, \mod (\prod{p_i})$)找到当前人数的最小可行解$x_0$，（如果$x_0$已经超过了$N$，直接输出无解即可）这时不难证明，对于任何一个可行解，都有 $$x_i = x_0 + k \times \prod{P_i},k \in \mathbb{N}$$

我们的目标是找到不超过$N$的最大可行解x',那么答案就是$N - x'$。注意这里如果直接枚举$k$的话有一个测试点会超时（看起来我的数据规模还是挺良心的……只卡掉了10分）。正确的做法是先用$N$减去$x_0$，这时剩下的部分就是$N - x' + k \times \prod{P_i},k \in \mathbb{N}$，那么我们只需用这个结果对$\prod{P_i}$取余即可得到答案。

 1 #include <cstdio>
 2 #include <cctype>
 3 #include <algorithm>
 4 #include <cstring>
 5 #include <queue>
 6 #include <cmath>
 7 #include <iostream>
 8 
 9 
 typedef long long LL;
 using namespace std;
 inline int lowbit(int x){return x & -x;}
 int gcd(int a, int b){return (!a) ? b : gcd(b % a, b);}
 template<typename T>T exgcd(T a, T b, T &x, T &y){
     , y = ; return b;}
     T d = exgcd(b % a, a, y, x);
     x -= (b/a) * y;
     return d;
 }
 /*=====================================*/
 inline LL inv(LL a, LL mod){
     LL x, y;
     );
     return (x % mod + mod) % mod;
 }
 LL n, M = , N[], e, S = ;
 ], a[], m;
 
 inline void init(){
     cin >> n >> m;
     ;i < m;++i){
         cin >> P[i] >> a[i];
         M *= P[i];
     }
     ;i < m;++i){
         N[i] = M / P[i];
         e = N[i] * inv(N[i], P[i]) % M;
         S = (S + e * a[i]) % M;
     }
 }
 
 inline void work(){
     LL x, y;
     exgcd<LL>(, M, x, y);
     x = ((x * S % M) + M ) % M;
      << endl;return;}
     cout << (n - x) % M << endl;
 }
 
 int main(){
     #if defined DEBUG
     freopen("test", "r", stdin);
     #else
     freopen("HanXin.in", "r", stdin);
     freopen("HanXin.out", "w", stdout);
     #endif
     
     init();
     
     work();
     
     ;
 }

中国剩余定理

【B、月考统计】

经典模型——差分约束系统。设第i位同学的分数为$x_i$，所有同学的最低分数为0. 则统计表中的每条息$i,j,a_{ij}$都可以形式化为 $$x_i - x_j \le a_{ij}$$。

对于这样一组不等式，我们可以抽象化出图论模型：每个同学都抽象为一个节点，再设一个起点0，表示所有同学的最低分数。对于每个不等式$x_i - x_j \le a_{ij}$，我们都从点i到点j连一条权值为$-a_{ij}$的有向边，表示从起点到点j的最长路权和最少比起点到i的最长路权和大$-a_{ij}$（可以用最长路的三角形不等式证明）。对于这样的图，用spfa求出从起点到每个点的最长路权和就是答案。

 1 /*=============================================================================================================================*/
 2 /*======================================================Code by Asm.Def========================================================*/
 3 /*=============================================================================================================================*/
 4 #include <cstdio>
 5 #include <iostream>
 6 #include <algorithm>
 7 #include <cmath>
 8 #include <cctype>
 9 #include <memory.h>
 #include <vector>
 #include <set>
 #include <string>
 #include <cstring>
 #include <map>
 #include <queue>
 #include <deque>
 #include <stack>
 #include <ctime>
 #include <iterator>
 #include <functional>
 #include <cstdlib>
 using namespace std;
 /*===================================================================================*/
 #define forall(it,v) for(__typeof(v.begin()) it = v.begin();it < v.end();++it) 
 #define pb push_back
 #define REP(i,j,k) for(i = j;i <= k;++i)
 #define REPD(i,j,k) for(i = j;i >= k;--i)
 #define iter(v) v::iterator
 typedef long long LL;
 template<typename T> void getint(T &x){
     char c = getchar();
     while(!isdigit(c))c = getchar();
     x = c - ';
      + c - ';
 }
 /*============================================================================================*/
  + ;
 int N, M;
 struct edge{
     int to, w;
     edge(int T, int W):to(T), w(W){}
 };
 vector<edge> adj[maxn];
 
 queue<int> Q;
 };
 }, cnt[maxn] = {};
 inline void init(){
     cin >> N >> M;
     int i, x, y, a;
     while(M--){
         cin >> x >> y >> a;
         adj[x].push_back(edge(y, -a));
     }
     ;i <= N;++i)
         Q.push(i);inQ[i] = ;cnt[i] = ;
 }
 inline void work(){
     int i, t;
     iter(vector<edge>) it;
     while(!Q.empty()){
         t = Q.front();Q.pop();inQ[t] = ;
         for(it = adj[t].begin();it != adj[t].end();++it)
             if(dis[t] + it->w > dis[it->to]){
                 dis[it->to] = dis[t] + it->w;
                 if(!inQ[it->to]){
                     if(cnt[it->to] == N){
                         cout << "SOMEONE LAY!" << endl;
                         return;
                     }
                     Q.push(it->to);inQ[it->to] = ;++cnt[it->to];
                 }
             }
     }
     ;i <= N;++i)
         cout << dis[i] << ' ';
 }
 
 int main(){
     #ifdef DEBUG
     freopen("test", "r", stdin);
     #else
     freopen("ExamStat.in", "r", stdin);
     freopen("ExamStat.out", "w", stdout);
     #endif
     
     init();
     work();
     
     #ifdef DEBUG
     //cout << endl << (double)clock() / CLOCKS_PER_SEC <<endl;
     #endif
     ;
 }

spfa解差分约束

【C、神奇的压缩机】

神奇的压缩机，神奇的阅读题……

这题改编自第21场Andrew Stankevich's Contest（俄国的ACM多校训练赛）的Lempel-Ziv Compression……

当时我的解法是预处理出字符串中每个子串的“满足i小于子串长度且i前缀与i后缀相等的i”的最大值（或 原串的每个后缀的KMP-next数组）……听起来相当拗口，不过套用KMP的预处理过程可以降低思维难度。

 1 //Verdict: Accepted 2 
 2 // Submission Date: 2014-10-02 16:34:32
 3 // Time: 8256MS
 4 // Memory: 34624KB
 5 
 6 /*======================================================Code by Asm.Def========================================================*/
 7 #include <cstdio>
 8 #include <iostream>
 9 #include <algorithm>
 #include <cmath>
 #include <cctype>
 #include <memory.h>
 #include <cstring>
 #include <cstdlib>
 using namespace std;
 #define maxn ((int)4.1e3)
 
 typedef long long LL;
   
 char ch[maxn];
 , minbit[maxn], *next[maxn];
 int l[maxn], r[maxn], str[maxn];
 
 
 inline void getnext(int l){
     int i, j, L = len - l;
     next[l] = ];
     int *Next = next[l];
     Next[] = ;
     ;i < L;++i){
         j = Next[i-] - ;
         ] && j >= )
             j = Next[j] - ;
         ])
             Next[i] = j + ;
         ;
     }
 }
 void printpro(int i){
     if(str[i] == i){
         );
         int j;
         for(j = r[i];j <= i;++j)putchar(ch[j]);
         return;
     }
     printpro(str[i]);
     printf("(%d,%d)", r[i], l[i]);
 }
 int main(){
     #ifdef DEBUG
     assert(freopen("test","r",stdin));
     #endif
 
     char c;
     while(isalpha(c = getchar()))str[len] = len, ch[len++] = c;
     int i, j, Min, t;
     ;i < len - ; ++i)
         getnext(i);
     minbit[] = ;
     ;i < len; ++i){
         Min = 0x7fffffff;
         ;j < i;++j)
              < Min){
                 Min = minbit[j] + (i-j)*;
                 str[i] = i;
                 r[i] = j+;
             }
         ;j < i; ++j){
             t = next[j][i-j];
             if(!t)continue;
              < Min){
                 Min = minbit[i-t] + ;
                 str[i] = i-t;
                 r[i] = i+-t-j;
                 l[i] = t;
             }
         }
         minbit[i] = Min;
     }
     printf(]);
     printpro(len-);
     ;
 }

动态规划