2016-11-15NOIP模拟赛

AM学军OJ

T1 暴力

#include<bits/stdc++.h>
 
using namespace std;
 
typedef long long LL;
const int N = 2000000 + 10;
 
int len, power;
 
int get_next(int x) {
    return x / 10 + x % 10 * power;
}
 
int vis[N], clk;
 
LL calc(int l, int r) {
    LL ans = 0;
    for(int i = l; i <= r; i++) if(vis[i] != clk) {
        int c = 0, x = i;
        for(int j = 0; 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 - 1) / 2;
    }
    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 = 0, power = 1; x; x /= 10) len++, power *= 10;
        power /= 10;
        //cerr << "!" << endl;
        //printf("%d
", calc(l, r));
        cout << calc(l, r) << endl;
    }
 
 
    return 0;
}

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

#include<bits/stdc++.h>
  
using namespace std;
  
const int N = 100 + 5, mod = 1000000009;
  
int d[N][N], g[N][N], f[N][N], n;
bool done[N][N];
  
int encode(int x, int y) {
    return x << 15 | y;
}
void discode(int s, int &x, int &y) {
    x = s >> 15;
    y = s & ((1 << 15) - 1);
}
  
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[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
  
bool inmap(int x, int y) {
    return 0 <= x && x < n && 0 <= y && y < n;
}
  
void dijkstra() {
    memset(done, 0, sizeof done);
    memset(d, 0x3f, sizeof d);
    insert(0, 0, g[0][0], 1);
    while(!q.empty()) {
        int x, y;
        discode(q.top().second, x, y); q.pop();
        if(done[x][y]) continue;
        done[x][y] = 1;
        if(x + y == n - 1) continue;
        for(int k = 0; k < 4; 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 = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                scanf("%d", g[i] + j);
                if(i + j >= n) {
                    int x = n - 1 - j, y = n - 1 - i;
                    //printf("(%d,%d) (%d,%d)
", i, j, x, y);
                    g[x][y] += g[i][j];
                    g[i][j] = 0;
                }
            }
        }
        dijkstra();
        int ans = ~0u >> 1, res = 0;
        for(int i = 0; i < n; i++) {
            ans = min(ans, d[i][n - i - 1]);
        }
        for(int i = 0; i < n; i++) {
            if(d[i][n - i - 1] == ans) {
                (res += f[i][n - i - 1]) %= mod;
            }
        }
        printf("%d
", res);
    }
    return 0;
}

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 = 200000 + 10;

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

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

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

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

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

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

#include<bits/stdc++.h>

using namespace std;

const int N = 500 + 10;

int n, K;

char s[N];

int f[N][105][105][2]; // 前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) >> 20) << endl;

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

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

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

    int ans = 0;

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

    printf("%d
", ans);

    return 0;
}

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 = 200000 + 10;

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

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 + 1));
}

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 + 1) - (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 << 1]);
    val[s] = max(val[s], val[s << 1 | 1]);
}

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 = 0;
    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[2000000 + 10];

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 = 0; i < n; i++) {
        scanf("%d", a + i); a[i] += 1000000;
    }
    for(int i = 0; i < m; i++) {
        scanf("%d%d", ql + i, qr + i);
        id[i] = i;
    }
    sort(id, id + m, cmp);
    for(int l = 0, r = 0, i = 0; r < n; r++) {
        while(vis[a[r]]) {
            vis[a[l++]] = 0;
        }
        vis[a[r]] = 1;
        modify(1, 0, n-1, l, r);
        while(i < m && qr[id[i]] == r) {
            ans[id[i]] = query(1, 0, n-1, ql[id[i]], r);
            i++;
        }
    }
    
    for(int i = 0; i < m; i++) {
        printf("%d
", ans[i]);
    }
    return 0;
}