NOIP 2015 提高组 Day2

期望得分：100+10+60=170

实际得分：100+10+35=145

http://www.cogs.pro/cogs/page/page.php?aid=16

T1 跳石头

时间限制：1 s 内存限制：256 MB

【题目描述】

这项比赛将在一条笔直的河道中进行,河道中分布着一些巨大岩石。组委会已经选

择好了两块岩石作为比赛起点和终点。在起点和终点之间,有 N 块岩石(不含起点和终点的岩石)。在比赛过程中,选手们将从起点出发,每一步跳向相邻的岩石,直至到达终点。

为了提高比赛难度,组委会计划移走一些岩石,使得选手们在比赛过程中的最短跳跃距离尽可能长。由于预算限制,组委会至多从起点和终点之间移走 M 块岩石(不能移走起点和终点的岩石)。

【输入格式】

输入文件第一行包含三个整数 L,N,M,分别表示起点到终点的距离,起点和终点之间的岩石数,以及组委会至多移走的岩石数。

接下来 N 行,每行一个整数,第 i 行的整数 Di(0 < Di < L)表示第 i 块岩石与起点的距离。这些岩石按与起点距离从小到大的顺序给出,且不会有两个岩石出现在同一个位置。

【输出格式】

输出文件只包含一个整数,即最短跳跃距离的最大值。

【样例输入】

【样例输出】

【提示】

输入输出样例 1 说明：将与起点距离为 2 和 14 的两个岩石移走后,最短的跳跃距离为 4(从与起点距离 17 的岩石跳到距离 21 的岩石,或者从距离 21 的岩石跳到终点)。

另：对于 20%的数据,0 ≤ M ≤ N ≤ 10。对于50%的数据,0 ≤ M ≤ N ≤ 100。

对于 100%的数据,0 ≤ M ≤ N ≤ 50,000,1 ≤ L ≤ 1,000,000,000。

二分最短距离

如果两块石头间距离比二分的还要短，

若此时还能移走石头，移走

否则return false

#include<cstdio>

#define N 50011

using namespace std;

int L,n,m,ans;

int a[N];

bool check(int k)

{

    int last=,tot=;

    for(int i=;i<=n+;i++)

     if(a[i]-a[last]<k)

     {

         if(tot<m) tot++;

        else  return false;

     }

     else last=i;

     return true;

}

int main()

{

    scanf("%d%d%d",&L,&n,&m);

    for(int i=;i<=n;i++) scanf("%d",&a[i]);

    int l=,r=L,mid;

    a[n+]=L;

    while(l<=r)

    {

        mid=l+r>>;

        if(check(mid)) ans=mid,l=mid+;

        else r=mid-;

    }

    printf("%d",ans);

}

T2 子串
时间限制：1 s 内存限制：128 MB

【题目描述】

有两个仅包含小写英文字母的字符串 A 和 B。现在要从字符串 A 中取出 k 个互不重叠的非空子串,然后把这 k 个子串按照其在字符串 A 中出现的顺序依次连接起来得到一个新的字符串,请问有多少种方案可以使得这个新串与字符串 B 相等?注意:子串取出的位置不同也认为是不同的方案。

【输入格式】

第一行是三个正整数 n,m,k,分别表示字符串 A 的长度,字符串 B 的长度,以及问题描述中所提到的 k,每两个整数之间用一个空格隔开。第二行包含一个长度为 n 的字符串,表示字符串 A。第三行包含一个长度为 m 的字符串,表示字符串 B。

【输出格式】

输出共一行,包含一个整数,表示所求方案数。由于答案可能很大,所以这里要求输出答案对 1,000,000,007 取模的结果。

【样例输入1】

6 3 1

aabaab

aab

【样例输出1】

【样例输入2】

6 3 2

aabaab

aab

【样例输出2】

【样例输入3】

6 3 3

aabaab

aab

【样例输出1】

【提示】

对于第 1 组数据:1≤n≤500,1≤m≤50,k=1;

对于第 2 组至第 3 组数据:1≤n≤500,1≤m≤50,k=2;

对于第 4 组至第 5 组数据:1≤n≤500,1≤m≤50,k=m;

对于第 1 组至第 7 组数据:1≤n≤500,1≤m≤50,1≤k≤m;

对于第 1 组至第 9 组数据:1≤n≤1000,1≤m≤100,1≤k≤m;

对于所有 10 组数据:1≤n≤1000,1≤m≤200,1≤k≤m。

令 f[i][j][k][0/1]表示A串前i个，分为k部分，匹配B串前j个，A串第i个不用/用的方案数

状态转移方程：

如果i不用，那他就是前i-1个的和 f[i][j][k][0]=f[i-1][j][k][0]+f[i-1][j][k][1]

如果i用，条件是a[i]=b[j] 那么它有2种决策：自成一堆，与前一个合为一堆

自成一堆的话，他的前一个可能用了，也可能没用，又分为了两种

所以 f[i][j][k][1]= f[i-1][j-1][k-1][1]（自成一堆，前一个用了）

+ f[i-1][j-1][k-1][0] （自成一堆，前一个没用）

+ f[i-1][j-1][k][1] （与前一个合为一堆，前一个必须用了）

边界条件：f[i][0][0][0]=1

边界研究了一晚上

f数组累积的前提是 a串中的第i个与b串的第一个相等

这时第i个只能自成一堆，f[i-1][1-1][k-1][0] = 1

最后用滚动数组滚动起来就A了

#include<cstdio>

#include<algorithm>

using namespace std;

int n,m,p,ans,s;

char a[],b[];

int f[][][][];

const int mod=;

int main()

{

    scanf("%d%d%d",&n,&m,&p);

    scanf("%s%s",a+,b+);

    f[][][][]=f[][][][]=;

    for(int i=;i<=n;i++)

    {

        int t=i%;

        for(int j=;j<=min(i,m);j++)

          for(int k=;k<=min(j,p);k++)

           {

                   f[t][j][k][]=(f[t^][j][k][]+f[t^][j][k][])%mod;

                   if(a[i]==b[j])   f[t][j][k][]=((f[t^][j-][k-][]+f[t^][j-][k-][])%mod+f[t^][j-][k][])%mod;

                   else f[t][j][k][]=;

           }

        ans=(ans+f[t][m][p][])%mod;

    }

}

#include <cstdio>

#include <cstring>

#include <iostream>

#include <algorithm>

using namespace std;

int n, m, k;

long long f[][][], s[][][];

char a[], b[];

const int mod = ;

int main()

{

    scanf("%d%d%d", &n, &m, &k);

    scanf("%s", a + );

    scanf("%s", b + );

    int now = , last = ;

    f[][][] = ;

    for (int i = ; i <= n; i++)

    {

        f[now][][] = ;

        for (int j = ; j <= min(i,m); j++)

            for (int kk = ; kk <= min(j,k); kk++)

            {

                if (a[i] == b[j])

                    s[now][j][kk] = (s[last][j - ][kk] + f[last][j - ][kk - ]) % mod;

                else

                    s[now][j][kk] = ;

                f[now][j][kk] = (f[last][j][kk] + s[now][j][kk]) % mod;

            }

        swap(now, last);

    }

    printf("%lld\n", f[last][m][k]);

    return ;

}

T3 运输计划

时间限制：1 s 内存限制：256 MB

【题目描述】

公元 2044 年,人类进入了宇宙纪元。

L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之间,这 n-1 条航道连通了 L 国的所有星球。

小 P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物

流飞船需要从 ui 号星球沿最快的宇航路径飞行到 vi 号星球去。显然,飞船驶过一条航道是需要时间的,对于航道 j,任意飞船驶过它所花费的时间为 tj,并且任意两艘飞船之间不会产生任何干扰。

为了鼓励科技创新,L 国国王同意小 P 的物流公司参与 L 国的航道建设,即允许小 P 把某一条航道改造成虫洞,飞船驶过虫洞不消耗时间。

在虫洞的建设完成前小 P 的物流公司就预接了 m 个运输计划。在虫洞建设完成后, 这 m 个运输计划会同时开始,所有飞船一起出发。当这 m 个运输计划都完成时,小 P 的物流公司的阶段性工作就完成了。

如果小 P 可以自由选择将哪一条航道改造成虫洞,试求出小 P 的物流公司完成阶段性工作所需要的最短时间是多少?

【输入格式】

第一行包括两个正整数 n、m,表示 L 国中星球的数量及小 P 公司预接的运输计划的数量,星球从 1 到 n 编号。

接下来 n-1 行描述航道的建设情况,其中第 i 行包含三个整数 ai, bi 和 ti,表示第i 条双向航道修建在 ai 与 bi 两个星球之间,任意飞船驶过它所花费的时间为 ti。接下来 m 行描述运输计划的情况,其中第 j 行包含两个正整数 uj 和 vj,表示第 j 个运输计划是从 uj 号星球飞往 vj 号星球。

【输出格式】

共 1 行,包含 1 个整数,表示小 P 的物流公司完成阶段性工作所需要的最短时间。

【样例输入】

【样例输出】

【提示】

所有测试数据的范围和特点如下表所示

请注意常数因子带来的程序效率上的影响。

所需技能：二分、lca、树链剖分、树上差分

求最值，很容易想到二分，那么我们就二分这个值k

如果最短时间为k，那么如果一个计划耗时超过k，那么它所经过的路径上就要有虫洞

可能有不止一个计划耗时超过k，

那么有可能改造为虫洞的路径是所有超时的计划路径的交集

如果这个交集中有一条路径，耗时>= 超出的时间（即不建虫洞的最大耗时-二分值）

那么把他改为虫洞可以使时间减少

现在就差如何求计划耗时和交集

计划耗时：树链剖分求lca，同时求出点到根节点的距离dis

计划耗时=dis[起点]+dis[终点]-2*dis[lca]

交集：树上差分

计划起点+1，终点+1，lca-2

然后从叶子节点向上累加

若点的sum等于超时计划数，则点与父节点之间的边在交集中

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<iostream>

#define N 300001

using namespace std;

int n,m,l,r,mid,ans,maxn;

int front[N],nextt[N*],to[N*],tot,w[N*];

int son[N],fa[N],dis[N],deep[N];

int id[N],bl[N],cnt;

int sum[N];

struct node

{

    int s,t,lca,dis;

}e[N];

void add(int u,int v,int x)

{

    to[++tot]=v; nextt[tot]=front[u]; front[u]=tot; w[tot]=x;

}

void dfs(int x)

{

    son[x]++;

    for(int i=front[x];i;i=nextt[i])

    {

        if(to[i]==fa[x]) continue;

        fa[to[i]]=x;

        dis[to[i]]=dis[x]+w[i];

        deep[to[i]]=deep[x]+;

        dfs(to[i]);

        son[x]+=son[to[i]];

    }

}

void dfs2(int x,int top)

{

    id[x]=++cnt;

    bl[x]=top;

    int y=;

    for(int i=front[x];i;i=nextt[i])

    {

        if(to[i]==fa[x]) continue;

        if(son[to[i]]>son[y]) y=to[i];

    }

    if(!y) return;

    dfs2(y,top);

    for(int i=front[x];i;i=nextt[i])

    {

        if(to[i]==fa[x]||to[i]==y) continue;

        dfs2(to[i],to[i]);

    }

}

void dfs3(int x)

{

    for(int i=front[x];i;i=nextt[i])

    {

        if(to[i]==fa[x]) continue;

        dfs3(to[i]);

        sum[x]+=sum[to[i]];

    }

}

int get_lca(int x,int y)

{

    while(bl[x]!=bl[y])

    {

        if(deep[bl[x]]<deep[bl[y]]) swap(x,y);

        x=fa[bl[x]];

    }

    if(deep[x]>deep[y]) x=y;

    return x;

}

bool check(int k)

{

    memset(sum,,sizeof(sum));

    int h=;

    for(int i=;i<=m;i++)

    {

        if(e[i].dis<=k) continue;

        sum[e[i].s]++; sum[e[i].t]++; sum[e[i].lca]-=;

        h++;

    }

    dfs3();

    for(int i=;i<=n;i++) if(sum[i]==h&&dis[i]-dis[fa[i]]>=maxn-k) return true;

    return false;

}

int main()

{

    /*freopen("transport.in","r",stdin);

    freopen("transport.out","w",stdout);*/

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

    int u,v,a;

    for(int i=;i<n;i++)

    {

        scanf("%d%d%d",&u,&v,&a);

        add(u,v,a);

        add(v,u,a);

    }

    for(int i=;i<=m;i++) scanf("%d%d",&e[i].s,&e[i].t);

    dfs();

    dfs2(,);

    for(int i=;i<=m;i++)

    {

        e[i].lca=get_lca(e[i].s,e[i].t);

        e[i].dis=dis[e[i].s]+dis[e[i].t]-*dis[e[i].lca];

        maxn=max(maxn,e[i].dis);

    }

    r=maxn;

    while(l<=r)

    {

        mid=l+r>>;

        if(check(mid)) { ans=mid; r=mid-;}

        else l=mid+;

    }

    printf("%d",ans);

}