8月5日集训队个人赛第七场解题报告

A Codeforces 204A

简单的数位DP。从高位到低位扫一遍就可以了。

#include <stdio.h>
#include <string.h>
typedef long long LL;
const int maxn = 20;
LL p[maxn];

LL DP(LL x){
    int bit[20], cnt = 0;
    for(LL n = x; n; bit[cnt ++] = n%10, n/=10);
    if(cnt==1) return x - 1;
    LL ans = 9;
    for(int i = 2; i <= cnt - 1; i ++)
        ans = ans + 9 * p[i-2];
    for(int i = cnt - 1, j = 1; i > 0; i --, j ++){
        if(i == cnt - 1) ans = ans + (bit[i] - 1) * p[cnt - j - 1];
        else ans = ans + bit[i] * p[cnt - j - 1];
    }
    if(bit[0] > bit[cnt-1]) ans ++;
    return ans;
}

int main(){
    p[0] = 1;
    for(int i = 1; i <= 18; i ++) p[i] = p[i-1] * 10;
    for(LL l, r; scanf("%I64d%I64d", &l, &r)!=EOF; printf("%I64d\n", DP(r+1) - DP(l)));
    return 0;
}

B Codeforces 120F

树形DP，寻找一棵树的最长直径。dp[i][2],0表示以i为根的子树中最长的链，1表示以i为根的子树中次长链，其中最长链与次长链没有共同的边只有一个i点位公共的根。第一次dfs求dp数组，第二次dfs时求以每个点为根的时候的最长直径，答案在i的子树中，最长链与次长链的和或者最长链与从父亲边过来的最长的链的和。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

const int maxn = 100+5;
int f[maxn], e[maxn*2], t[maxn*2];
int d[maxn][2], c[maxn][2];
int tot;

void add(int u, int v){
    e[tot] = f[u];
    t[tot] = v;
    f[u] = tot ++;
}
void dfs1(int u, int fa){
    d[u][0] = d[u][1] = 0;
    c[u][0] = c[u][1] = 0;
    for(int i = f[u]; i != -1; i = e[i]){
        int v = t[i];
        if(v==fa) continue;
        dfs1(v, u);
        if(d[v][0] + 1 <= d[u][1]) continue;
        d[u][1] = d[v][0] + 1;
        c[u][1] = v;
        if(d[u][1] > d[u][0]){
            swap(d[u][1], d[u][0]);
            swap(c[u][1], c[u][0]);
        }
    }
}
void dfs2(int u, int fa, int l, int &ans){
    ans = max(ans, d[u][0] + d[u][1]);
    ans = max(ans, d[u][0] + l);
    for(int i = f[u]; i != -1; i=e[i]){
        int v = t[i];
        if(v==fa) continue;
        if(v != c[u][0])
            dfs2(v, u, max(l + 1, d[u][0] + 1), ans);
        else
            dfs2(v, u, max(l + 1, d[u][1] + 1), ans);
    }
}
int main(){
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    for(int n, ans; scanf("%d", &n)!=EOF;){
        ans = 0;
        for(int i = 1, m; i <= n; i ++){
            scanf("%d", &m);
            memset(f, -1, sizeof(f));tot=0;
            for(int i = 1, u, v; i < m; i ++){
                scanf("%d%d", &u, &v);
                add(u, v);
                add(v, u);
            }
            dfs1(1, 0);
            int tmp = 0; dfs2(1, 0, 0, tmp);
            ans = ans + tmp;
        }
        printf("%d\n", ans);
    }
    return 0;
}

C Codeforces 29D

LCA+模拟。由于点比较少，直接用并查集，不适用路径压缩,并且对每个点维护一个到根的距离。然后每次就直接查最近公共祖先，然后模拟走就可以了。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define maxn 310

int dfn[maxn], f[maxn], head[maxn], order[maxn];
int euler[maxn*2], e[maxn*2], g[maxn*2];
int tot, pos;
int stack[maxn];

void add(int u, int v){
    e[tot] = head[u];
    g[tot] = v;
    head[u] = tot ++;
}

int dfs(int v, int fa, int depth){
    dfn[v] = depth + 1;
    f[v] = fa;
    int son = 0, flag = 1;
    for(int i = head[v] ; i != -1; i = e[i]){
        int u = g[i];
        if(u==fa) continue;
        son += dfs(u, v, depth+1);
        flag = 0;
    }
    son += flag;
    return son;
}

int getAncestor(int u, int v){
    for(;dfn[u]!=dfn[v];){
        if(dfn[u]>dfn[v]) u = f[u];
        else v = f[v];
    }
    for(;u!=v; u = f[u], v = f[v]);
    return u;
}

void up(int v, int fa){
    for(v = f[v];v!=fa;v = f[v]){
        euler[pos ++] = v;
    }
    euler[pos ++] = fa;
}
void down(int v, int fa){
    int top = 0;
    for(v; v != fa; v = f[v]){
        stack[top++] = v;
    }
    for(;top; euler[pos ++] = stack[--top]);
}

int main(){
    //freopen("test.in", "r", stdin);
    for(int n; scanf("%d", &n)!=EOF;){
        tot = pos = 0;
        memset(head, -1, sizeof(head));
        for(int i = 1, x, y; i < n; i ++){
            scanf("%d%d", &x, &y);
            add(x, y);
            add(y, x);
        }
        int leafn = dfs(1, 1, 1);
        for(int i = 0; i < leafn; i ++){
            scanf("%d", &order[i]);
        }
        euler[pos ++] = 1;
        down(order[0], 1);
        for(int i = 1, last = order[0]; i < leafn; i ++){
            int ancestor = getAncestor(last, order[i]);
            //printf(">> ancestor: %d\n", ancestor);
            up(last, ancestor);
            down(order[i], ancestor);
            last = order[i ];
            if(pos > 2*n-1){
                break;
            }
        }
        up(order[leafn-1], 1);
        if(pos > 2*n-1){
            printf("-1\n");
        }
        else{
            for(int i = 0; i < pos; i ++){
                printf("%d ", euler[i]);
            }
            printf("\n");
        }
    }
    return 0;
}

D Codeforces 128B

优先队列模拟就可以了。先把长度为1的丢进去，然后每次取出一个元素后，进行扩展(+1位)

#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
#include <string>
#include <iostream>
#include <functional>
using namespace std;

struct Node{
    string first;
    int second;
    bool operator<(const Node &a)const{
        return first > a.first;
    }
};
Node make_node(string s, int p){
    Node a;
    a.first = s, a.second = p;
    return a;
}

int main(){
    string a, s = "";
    int k, i, pos;
    cin>>a; cin>>k;
    priority_queue<Node> Q;
    for(i = 0; i < a.size(); i ++){
        Q.push(make_node(s + a[i], i));
    }
    for(i = 0; i < k - 1 && !Q.empty(); i ++){
        s = Q.top().first;
        pos = Q.top().second;
        Q.pop();
        if(pos + 1 < a.size()){
            Q.push(make_node(s + a[pos + 1], pos + 1));
        }
    }
    if(i < k - 1 || i == k - 1 && Q.empty()){
        cout<<"No such line."<<endl;
    }
    else cout<<Q.top().first<<endl;
    return 0;
}

E Codeforces 178B1~178B3

求从一个点到另一个点的路径上最少经过的割边是多少。

先用tarjan求边双连通分量，然后染色，将割边记录下来，然后建树。然后对树做欧拉环游,并得到每个点到根的距离，对得到的序列做RMQ，对于询问x, y

其结果就是dfn[col[x]] + dfn[col[y]] - dfn[ance]，其中ance时col[x], col[y]的最近公共祖先。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn = 100005;
const int maxm = 100005;
typedef int arr[maxn];
arr head, dfn, low, col, st;
int top, depth, color, tot, cnt;
pair<int, int> e[maxm*2], bridge[maxn];
int euler[maxn*3], d[maxn*3][30], pos;

void add(int x, int y){
    e[tot] = make_pair(head[x], y);
    head[x] = tot ++;
}
void tarjan(int u, int f){
    dfn[u] = low[u] = ++depth;
    st[++top] = u;
    for(int i = head[u]; i != -1; i = e[i].first){
        int v = e[i].second;
        if(v==f) continue;
        if(!dfn[v]){
            tarjan(v, u);
            low[u] = min(low[v], low[u]);
        }
        else low[u] = min(low[u], dfn[v]);
        if(low[v] > dfn[u])
            bridge[cnt ++] = make_pair(u, v);
    }
    if(dfn[u] == low[u]){
        int x; color ++;
        do{
            col[x = st[top--]] = color;
        }while(x != u);
    }
}
void dfs(int u, int f){
    euler[++ pos] = u; low[u] = pos;
    for(int i = head[u]; i != -1; i = e[i].first){
        int v = e[i].second;
        if(v==f) continue;
        dfn[v] = dfn[u] + 1;
        dfs(v, u);
        euler[++pos] = u;
    }
}
void RMQ_init(){
    for(int i = 1; i <= pos; i ++) d[i][0] = i;
    for(int j = 1; (1<<j) <= pos; j ++){
        for(int i = 1; i + j - 1<= pos; i ++){
            if(dfn[euler[d[i][j-1]]] < dfn[euler[d[i + (1<<(j-1))][j-1]]]){
                d[i][j] = d[i][j-1];
            }
            else d[i][j] = d[i + (1<<(j-1))][j-1];
        }
    }
}
int RMQ(int L, int R){
    int k = 0;
    if(L > R) swap(L, R);
    while((1<<(k+1)) <= R-L+1) k ++;
    return dfn[euler[d[L][k]]] < dfn[euler[d[R-(1<<k)+1][k]]] ? d[L][k] : d[R-(1<<k)+1][k];
}
int main(){
    //freopen("test.in", "r", stdin);
    for(int n, m, Q; scanf("%d%d", &n, &m)!=EOF; ){
        depth = color = tot = top = cnt =0;
        for(int i = 1; i <= n; i ++){
            head[i] = -1, dfn[i] = 0;
        }
        for(int i = 1, x, y; i <= m; i ++){
            scanf("%d%d", &x, &y);
            add(x, y);
            add(y, x);
        }
        tarjan(1, -1);
        tot = 0;
        for(int i = 0; i <= color; i ++){
            head[i] = -1;
            dfn[i] = 0;
        }
        for(int i = 0; i < cnt; i ++){
            add(col[bridge[i].first], col[bridge[i].second]);
            add(col[bridge[i].second], col[bridge[i].first]);
        }
        pos = dfn[1] = 0;
        dfs(1, 0);
        RMQ_init();
        scanf("%d", &Q);
        for(int i = 1, x, y; i <= Q; i ++){
            scanf("%d%d", &x, &y);
            int ance = RMQ(low[col[x]], low[col[y]]); ance = euler[ance];
            printf("%d\n", dfn[col[x]] + dfn[col[y]] - 2 * dfn[ance]);
        }
    }
    return 0;
}

F URAL 1671

并查集。倒着搞就是了，先将没有删除的边合并，然后按照从后往前加边就是了。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

const int maxn = 100005;
const int maxm = 100000+10;
int f[maxn], h[maxm], s[maxm];
bool mark[maxm];
pair<int, int> edge[maxm];

int find(int x){
    return x ==f[x] ? x : (f[x] = find(f[x]));
}

int main(){
    for(int n, m;scanf("%d%d", &n, &m)!=EOF;){
        for(int i = 1; i <= n; i ++) f[i] = i;
        for(int i = 1, x, y; i <= m; i ++){
            scanf("%d%d", &x, &y);
            edge[i] = make_pair(x, y);
        }
        int q, cnt = n; scanf("%d", &q);
        for(int i = 1, x; i <= q; i ++){
            scanf("%d", &x);
            mark[x] = 1;
            h[i] = x;
        }
        for(int i = 1; i <= m; i ++){
            if(!mark[i]){
                int x = find(edge[i].first);
                int y = find(edge[i].second);
                if(x == y) continue;
                f[x] = y;
                cnt --;
            }
        }
        for(int i = q; i >= 1; i --){
            s[i] = cnt;
            int x = find(edge[h[i]].first);
            int y = find(edge[h[i]].second);
            if(x==y) continue;
            f[x] = y;
            cnt --;
        }
        for(int i = 1; i <= q; i ++){
            if(i != 1) printf(" ");
            printf("%d", s[i]);
        }
        printf("\n");
    }
    return 0;
}