2016-11-15NOIP模拟赛

AM学军OJ

T1 暴力

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long LL;
 const int N =  + ;

 int len, power;

 int get_next(int x) {
     return x /  + x %  * power;
 }

 int vis[N], clk;

 LL calc(int l, int r) {
     LL ans = ;
     for(int i = l; i <= r; i++) if(vis[i] != clk) {
         int c = , x = i;
         for(int j = ; j < len; j++) {
             if(l <= x && x <= r && vis[x] != clk) {
                 vis[x] = clk, c++;
             }
             //cout << x << endl;
             x = get_next(x);
         }
         //cout << "--" << ans << endl;
         ans += c * (c - ) / ;
     }
     return ans;
 }

 int main() {

     int T;
     scanf("%d", &T);
     while(T--) {
         //memset(vis, 0, sizeof vis);
         clk++;
         int l, r, x;
         scanf("%d%d", &l, &r); x = l;
         for(len = , power = ; x; x /= ) len++, power *= ;
         power /= ;
         //cerr << "!" << endl;
         //printf("%d\n", calc(l, r));
         cout << calc(l, r) << endl;
     }

     return ;
 }

T2 最短路 比赛的时候统计方案的时候由u更新v的最短路以后直接把到v的最短路方案赋为1而不是u的方案数。

 #include<bits/stdc++.h>

 using namespace std;

 const int N =  + , mod = ;

 int d[N][N], g[N][N], f[N][N], n;
 bool done[N][N];

 int encode(int x, int y) {
     return x <<  | y;
 }
 void discode(int s, int &x, int &y) {
     x = s >> ;
     y = s & (( << ) - );
 }

 typedef pair<int, int> pii;

 priority_queue<pii, vector<pii>, greater<pii> > q;

 void insert(int x, int y, int z, int k) {
     if(d[x][y] > z) {
         d[x][y] = z;
         f[x][y] = k;
         q.push(pii(z, encode(x, y)));
     } else if(d[x][y] == z) {
         f[x][y] += k;
         if(f[x][y] >= mod) f[x][y] -= mod;
     }
 }

 const int dx[] = {, , , -};
 const int dy[] = {, -, , };

 bool inmap(int x, int y) {
     return  <= x && x < n &&  <= y && y < n;
 }

 void dijkstra() {
     memset(done, , sizeof done);
     memset(d, 0x3f, sizeof d);
     insert(, , g[][], );
     while(!q.empty()) {
         int x, y;
         discode(q.top().second, x, y); q.pop();
         if(done[x][y]) continue;
         done[x][y] = ;
         if(x + y == n - ) continue;
         for(int k = ; k < ; k++) {
             int xx = x + dx[k], yy = y + dy[k];
             if(!inmap(xx, yy)) continue;
             insert(xx, yy, d[x][y] + g[xx][yy], f[x][y]);
         }
     }
 }

 int main() {
     while(~scanf("%d", &n) && n) {
         for(int i = ; i < n; i++) {
             for(int j = ; j < n; j++) {
                 scanf("%d", g[i] + j);
                 if(i + j >= n) {
                     int x = n -  - j, y = n -  - i;
                     //printf("(%d,%d) (%d,%d)\n", i, j, x, y);
                     g[x][y] += g[i][j];
                     g[i][j] = ;
                 }
             }
         }
         dijkstra();
         int ans = ~0u >> , res = ;
         for(int i = ; i < n; i++) {
             ans = min(ans, d[i][n - i - ]);
         }
         for(int i = ; i < n; i++) {
             if(d[i][n - i - ] == ans) {
                 (res += f[i][n - i - ]) %= mod;
             }
         }
         printf("%d\n", res);
     }
     return ;
 }

T3 题目转化为对于$n$个二元组$(e_1,e_2)e_1,e_2$代表两条边，如果这两条边中的一条加入了图中，则对答案贡献1，图不能成环，求答案的最大值。

如果不是二元组而是一元组也就是一条边，就用最大生成树即可，最大生成树为什么是对的呢？拟阵可以证明。也就是说对于任意一个中间状态，如果这条边能够加进来（即没有自环），那么一定有一种最优解会包含这条边，用在这里也同理。当我们想加入一个二元组的时候，如果$e_1,e_2$中的一条可以直接加进去，那就直接加进去，如果都不能，就考虑删掉环上一条边，而删掉了这条边就要加入那个二元组的另一条边，这类似于二分图最大匹配的过程。

PM

T1 二分答案

 #include<bits/stdc++.h>

 using namespace std;

 const int N =  + ;

 int L[N], R[N], S[N];
 int n;

 bool check(double v) {
     double T = ;
     for(int i = ; i < n; i++) {
         T += S[i] / v;
         if(T > R[i]) return ;
         if(T < L[i]) T = L[i];
     }
     return ;
 }

 int main() {
     freopen("express.in", "r", stdin);
     freopen("express.out", "w", stdout);

     scanf("%d", &n);
     for(int i = ; i < n; i++) {
         scanf("%d%d%d", L + i, R + i, S + i);
     }
     double l = , r = 1e15;
     check();
     while(r - l > 1e-) {
         double mid = (l + r) / ;
         if(check(mid)) r = mid;
         else l = mid;
     }

     printf("%.2f\n", l);
     return ;
 }

T2 dp 在比赛的时候，只写了j <= i而没有写j <= K导致数组溢出，数组只开了101却用到了101这个位置。

 #include<bits/stdc++.h>

 using namespace std;

 const int N =  + ;

 int n, K;

 char s[N];

 int f[N][][][]; // 前i位改变了j个0和k个1,第i位为l

 void maxit(int &x, int y) {
     if(x < y) x = y;
 }

 int main() {
     freopen("welcome.in", "r", stdin);
     freopen("welcome.out", "w", stdout);
     cerr << ((sizeof f) >> ) << endl;

     scanf("%d%d", &n, &K);

     scanf("%s", s + );
     for(int i = ; i <= n; i++) {
         s[i] = s[i] == 'z';
     }

     memset(f, -0x3f, sizeof f);
     if(s[] == ) {
         f[][][][] = ;
         f[][][][] = ;
     }
     else {
         f[][][][] = ;
         f[][][][] = ;
     }
     for(int i = ; i < n; i++) {
         for(int j = ; j <= i && j <= K; j++) {
             for(int k = ; j + k <= i && k <= K; k++) {
                 int t1 = max(f[i][j][k][], f[i][j][k][]),
                     t2 = max(f[i][j][k][] + , f[i][j][k][]);
                 if(s[i+] == ) {
                     maxit(f[i+][j][k][], t1);
                     maxit(f[i+][j+][k][], t2);
                 } else {
                     maxit(f[i+][j][k][], t2);
                     maxit(f[i+][j][k+][], t1);
                 }
             }
         }
     }

     int ans = ;

     for(int i = ; i <= K; i++) {
         maxit(ans, f[n][i][i][]);
         maxit(ans, f[n][i][i][]);
     }

     printf("%d\n", ans);

     return ;
 }

T3

题目描述】
A是某公司的CEO，每个月都会有员工把公司的盈利数据送给A，A是个与众不同的怪人，A不注重盈利还是亏本，而是喜欢研究“完美序列”：连续的互不相同的序列。A想知道区间[L,R]之间最长的完美序列。
【输入格式】
第一行两个整数N，M(1<=N,M<=200000)，N表示连续N个月,编号为0到N-1，M表示询问的次数。第二行N个整数(绝对值不
超过106),第i个数表示该公司第i个月的盈利值。接下来M行每行两个整数L,R(0<=L<=R<=N-1),表示A询问的区间。

【输出格式】
输出M行，每行一个整数对应询问区间内的完美序列的最长长度。
【样例输入】
9 2
2 5 4 1 2 3 6 2 4
0 8
2 6
4 8
【样例输出】
6
5
4

这道题网上普遍流传着一个算法，就是统计出以每个位置为前缀的最长长度，这个显然是不减的，然后对于询问区间内的最最长度，前一段可能超过了$L_i$，这时取最靠右的位置，后面一段没有超过，直接询问最大值。

我的做法是在线段树上加上等差数列的标记，并需要离线处理。

 #include<bits/stdc++.h>

 using namespace std;

 typedef pair<int, int> pii;
 #define FI first
 #define SE second
 const int N =  + ;

 #define mid ((l + r) >> 1)
 #define ls s << 1, l, mid
 #define rs s << 1 | 1, mid + 1, r
 int tag[N * ], val[N * ];

 void add_tag(int s, int l, int r, int d) {
     tag[s] = max(tag[s], d);
     val[s] = max(val[s], d);
 }

 void down(int s, int l, int r) {
     add_tag(ls, tag[s]);
     add_tag(rs, tag[s] - (mid - l + ));
 }

 void modify(int s, int l, int r, int L, int R) {
     if(L <= l && r <= R) return add_tag(s, l, r, (R - L + ) - (l - L));
     down(s, l, r);
     if(L <= mid) modify(ls, L, R);
     if(mid < R) modify(rs, L, R);
     val[s] = max(val[s], val[s << ]);
     val[s] = max(val[s], val[s <<  | ]);
 }

 int query(int s, int l, int r, int L, int R) {
     if(L <= l && r <= R) return val[s];
     down(s, l, r);
     int res = ;
     if(L <= mid) res = max(res, query(ls, L, R));
     if(mid < R) res = max(res, query(rs, L, R));
     return res;
 }

 int n, m, a[N];
 int ql[N], qr[N], id[N], ans[N];
 bool vis[ + ];

 bool cmp(int a, int b) {
     return qr[a] < qr[b];
 }

 int main() {
     freopen("diff.in", "r", stdin);
     freopen("diff.out", "w", stdout);

     scanf("%d%d", &n, &m);
     for(int i = ; i < n; i++) {
         scanf("%d", a + i); a[i] += ;
     }
     for(int i = ; i < m; i++) {
         scanf("%d%d", ql + i, qr + i);
         id[i] = i;
     }
     sort(id, id + m, cmp);
     for(int l = , r = , i = ; r < n; r++) {
         while(vis[a[r]]) {
             vis[a[l++]] = ;
         }
         vis[a[r]] = ;
         modify(, , n-, l, r);
         while(i < m && qr[id[i]] == r) {
             ans[id[i]] = query(, , n-, ql[id[i]], r);
             i++;
         }
     }

     for(int i = ; i < m; i++) {
         printf("%d\n", ans[i]);
     }
     return ;
 }