Codeforces Round #244 (Div. 2)（解题报告）

A. Police Recruits

题意：按照时间顺序给出N个整数ai代表N个事件，ai大于0时代表增加ai个警察，否则代表出现一次犯罪。

当出现犯罪时，

如果警察数量大于0，那么就派一个警察过去调查这个案子，然后他就这样耗费了一辈子o(︶︿︶)o ，警察人数减一；

否则这个案子就没有人调查；

问题就是统计有多少个案子没有被调查。

按照题意慢慢模拟就行啦。

#include<cstdio>
int n, i, a, x, ans;
int main(){
    while(~scanf("%d", &n)){
        ans=0;
        x=0;
        for(i=0; i<n; i++){
            scanf("%d", &a);
            if(a<0){
                if(!x)	ans++;
                else	x--;
            }
            else	x+=a;
        }
        printf("%d\n", ans);
    }
    return 0;
}

B. Prison Transfer

题意：给定N个数，从中选择连续的c个数出来，并且这c个数都不大于一个给定的t，问有多少种选择。

因为选择的数字是在连续区间上，所以可以将大于t的数字取走，剩下若干个区间，那么这些区间里面，长度小于c的就忽略，否则这个区间就有区间长度L-c+1种取法（也就是长度为c的连续子区间），所有取法累加就是答案。

具体实现的时候，可以一遍读数字一遍统计，遇到大于t的数字就判断当前长度是否足以取数，更新答案；

#include<cstdio>
#include<cstring>
int n, t, c, i;
int a[200000], ans, cur;
int main(){
    while(~scanf("%d %d %d", &n, &t, &c)){
        for(i=0; i<n; i++)	scanf("%d", a+i);
        ans=cur=0;
        for(i=0; i<n; i++){
            if(a[i]>t){
                if(cur>=c)	ans += cur-c+1;
                cur=0;
            }
            else	cur++;
        }
        if(cur>=c)	ans += cur-c+1;
        printf("%d\n", ans);
    }
    return 0;
}

C. Checkposts

题意：给定一个N个点的有向图，在i点建造保安亭（是这样的吧？反正大概这意思。。。）会有wi的花费，建造之后这里就会有警察蜀黍站岗啦，然后对于一个j点，这个警察蜀黍能够保护j点的情况只有两种：1是j就是i点；2是存在i到j的路径，并且还要能从j回到i。在这样的条件下，要求能够保护到所有点的建造方案，这个方案必须花费最少，并且建造的点也必须最少，输出这个最少花费，同时要输出这个最少花费的不同方案数模10^9+7，两种方案只要有一个点选择不同，就视为不同方案。

按照题目的说法，如果i能保护到j，那么i和j必须属于同一个强连通分量，换句话说，对于一个强连通分量只需要选择一个点就能保护这个强连通分量里的点，其它点管不着。。。

所以第一个任务是找到图里面的所有强连通分量，这个在《训练指南》里有介绍。

然后找到每个强连通分量里面花费最少的点，同时统计个数。

把所有花费加起来就是总最小花费，由于每个强连通分量只选一个，所以个数肯定最少。

把每个强连通分量里面统计到的个数乘起来就是方案数了。

#include<cstdio>
#include<cstring>
#include<vector>
#include<stack>
#include<algorithm>
using namespace std;
#define N 100001
#define mod 1000000007
#define LL long long
vector<int> G[N];
int pre[N], lowlink[N], sccno[N], dfs_clock, scc_cnt;
stack<int> ST;
LL ans;
int cnt[N], cost[N], w[N];
void dfs(int u){
    pre[u]=lowlink[u]=++dfs_clock;
    ST.push(u);
    for(int i=0; i<G[u].size(); i++){
        int v=G[u][i];
        if(!pre[v]){
            dfs(v);
            lowlink[u]=min(lowlink[u], lowlink[v]);
        }
        else if(!sccno[v]){
            lowlink[u] = min(lowlink[u], pre[v]);
        }
    }
    if(lowlink[u]==pre[u]){
        scc_cnt++;
        for(;;){
            int x=ST.top(); ST.pop();
            sccno[x] = scc_cnt;
            if(x==u)	break;
        }
    }
}
void find_scc(int n){
    dfs_clock = scc_cnt = 0;
    memset(sccno, 0, sizeof(sccno));
    memset(pre, 0, sizeof(pre));
    for(int i=1; i<=n; i++){
        if(!pre[i])	dfs(i);
    }
}
int main(){
    int n, m, x, y;
    while(~scanf("%d", &n)){
        for(int i=1; i<=n; i++){
            G[i].clear();
            scanf("%d", w+i);
        }
        scanf("%d", &m);
        while(m--){
            scanf("%d %d", &x, &y);
            G[x].push_back(y);
        }
        find_scc(n);
        memset(cost, -1, sizeof(cost));
        for(int i=1; i<=n; i++){
            x = sccno[i];
            if(cost[x]==-1 || w[i]<cost[x]){
                cost[x] = w[i];
                cnt[x] = 1;
            }
            else if(cost[x]==w[i]){
                cnt[x]++;
            }
        }
        LL u=0;
        ans = 1;
        for(int i=1; i<=scc_cnt; i++){
            u += (LL)cost[i];
            ans = (ans * (LL)cnt[i])%mod;
        }
        printf("%I64d %I64d\n", u, ans);
    }
    return 0;
}

D. Match & Catch

题意：给定两个字符串A和B，要找到一个长度最短的字符串，使得它同时是A和B的子串，并且在A和B中都只是出现一次。如果不存在就输出-1。

把A和B拼起来，然后跑一下后缀数组，求出height数组。

然后是枚举长度，对于一个给定长度X，看看height数组中是否有连续一段值不小于X，并且统计里面属于A的个数f1,属于B的个数f2，如果f1和f2同时等于1，就是找到了。这里可以先记录A的长度len1，如果下标i小于len1的，就是A的子串，如果大于len1就是B的串；

PS：今天居然就这样翻了两次《训练指南》。。。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 11000
char A[N], B[N];
char s[N];
int sa[N], t[N], t2[N], c[N], n;
void build_sa(int m){
    int i, *x=t, *y=t2;
    for(i=0; i<m; i++)	c[i]=0;
    for(i=0; i<n; i++)	c[x[i]=s[i]]++;
    for(i=1; i<m; i++)	c[i]+=c[i-1];
    for(i=n-1; i>=0; i--)	sa[--c[x[i]]] = i;
    for(int k=1; k<=n; k<<=1){
        int p=0;
        for(i=n-k; i<n; i++)	y[p++]=i;
        for(i=0; i<n; i++)	if(sa[i]>=k)	y[p++]=sa[i]-k;
        for(i=0; i<m; i++)	c[i]=0;
        for(i=0; i<n; i++)	c[x[y[i]]]++;
        for(i=1; i<m; i++)	c[i]+=c[i-1];
        for(i=n-1; i>=0; i--)	sa[--c[x[y[i]]]] = y[i];
        swap(x, y);
        p=1; x[sa[0]]=0;
        for(i=1; i<n; i++)
            x[sa[i]] = y[sa[i-1]]==y[sa[i]] && y[sa[i-1]+k]==y[sa[i]+k]?p-1:p++;
        if(p>=n)	break;
        m=p;
    }
}
int len1, len2;
int rank[N], height[N];
void getheight(){
    int i, j, k=0;
    for(i=0; i<n; i++)	rank[sa[i]]=i;
    for(i=0; i<n; i++){
        if(k)	k--;
        int j=sa[rank[i]-1];
        while(s[i+k]==s[j+k])	k++;
        height[rank[i]] = k;
    }
}
bool check(int x){
    int f1, f2;
    f1=f2=0;
    for(int i=1; i<n; i++){
        if(height[i]>=x){
            if(sa[i-1]<len1)	f1++;
            if(sa[i-1]>len1)	f2++;
        }
        else{
            if(sa[i-1]<len1)	f1++;
            if(sa[i-1]>len1)	f2++;
            if(f1==1 && f2==1)	return 1;
            f1=f2=0;
        }
    }
    return 0;
}
int main(){
    while(~scanf("%s", A)){
        scanf("%s", B);
        len1 = strlen(A);
        len2 = strlen(B);
        for(int i=0; i<len1; i++){
            s[i] = A[i]-'a'+1;
        }
        s[len1] = 27;
        for(int i=0; i<len2; i++){
            s[i+1+len1] = B[i]-'a'+1;
        }
        n = len1+len2+2;
        s[n-1] = 0;
        build_sa(28);
        getheight();
        bool find=0;
        for(int i=1; i<=min(len1,len2); i++){
            if(check(i)){
                find=1;
                printf("%d\n", i);
                break;
            }
        }
        if(!find)	puts("-1");
    }
    return 0;
}

E. Police Patrol

题意：在x轴上面有N个犯罪现场（呃。。。今晚的罪犯跟警察真多。。。），然后呢，你要在x轴上面选择一个点作为根据地，接着你要开着你的宝马出去抓罪犯~~可是呢，你的车一次最多只能载M个罪犯，并且每次逮捕完都必须回到根据地。这里说到的点坐标值都是整数（包括你的根据地）。

然后问题就来了，你要选择一个合适的地方，使得你的宝马跑的距离最少，要注意你的距离都是往返两次的，输出最短的距离。题目中说了同一地点可能会有多个犯罪者。

由于题目输入的坐标已经从小到大排好序了，所以我们省去排序的工作。

最一开始的区间就是[0,n-1]这个区间，那么最左边坐标是a[0], 最右边是a[n-1]，抓到这两个，首先你必须让你的据点在他们中间，但是，无论你选择在哪，你要抓到他们的距离都是2(a[n-1]-a[0])，这个可以稍微证明下，假设选择了(x,0)这个点，那么左边的距离就是2(x-a[0]),右边2(a[n-1]-x)，加起来就是上面的距离了。既然无论选在哪，要抓到他们都得跑2(a[n-1]-a[0])，那就干脆多拉几个人咯，最多拉几个呢？往左边最多可以m个人，往右边最多可以m个人，所以这里左右跑下来可以去掉2m个人，这个区间就变成[l+m,r-m]，如果l+m > r-m了，那就说明这个区间的人抓光了。

所以，这个问题可以通过这样逐步缩小区间解决，采用递归应该是比较方便的写法。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
int n, m;
int a[1000000];
LL cal(int l, int r){
    if(l>r)	return 0;
    int len = r-l+1;
    if(len<=m)	return (LL)(a[r]-a[l]);
    return (LL)(a[r]-a[l]) + cal(l+m, r-m);
}
int main(){
    while(~scanf("%d %d", &n, &m)){
        for(int i=0; i<n; i++)	scanf("%d", a+i);
        printf("%I64d\n", cal(0,n-1)*2);
    }
    return 0;
}