比赛-暑假训练赛1 (26 Jul, 2018)

A. 密码 没有想到题解里机智的 P2-P1 避免重复计算，我以为是一个类似最长公共子串的 DP，OrzOrzOrz。 设输入分别为 A, B 两个字符串。f[i][j] 表示 A 串前 i 位与 B 串前 j 位匹配（ B 串中字母可以依次在 A 中找到）的方案数。 当 A[i] == B[j], f[i][j] = f[i-1][j-1] 当 A[i] != B[j], f[i][j] = f[i-1][j] 。 显然 f[i][0] = i 。然后直接这样写会爆空间，注意到 i 这维可以滚动掉。答案是 ∑f[i][lenB] 。

B. 独立集 如果 i < j 且 A[i] < A[j] ，那么 i, j 就不会连边，就能够放在一个集合里。再推一下会发现第一问是求最长上升子序列。第二问可以脑补出这个东西：某个点确定的充要条件是：原序列以它为最后一个元素和第一个元素的单升，都有且仅有 1 个。后者可以转换为：反过来的序列里以它为最后一个元素的单降有且仅有 1 个。把 for 反着写然后让A[i] = -A[i]，就把反向单降转化得和正向单升一样了。

C. 益智游戏 先跑最短路，然后枚举边 x->y = w，对 dis(A, x) + w + dis(y, B) = dis(A, B) 且 dis(C, x) + w + dis(y, D) = dis(C, D) 的边做一个标记。显然最终的点都在这些边上。然后问题转化为求最长链+1（点数）。可以用 DP，f[x] = max{ f[i] } + 1 (满足有边从 i 到 x) 。其实写起来是记忆化搜索。由于上次做过一道什么轰炸城市的题，也是求最长链，被大佬们告知直接 topsort 就可以了不用搜索，所以考试的时候写了发 topsort 。另外样例第 2 组就是菊花图，会卡掉 SPFA （因为边数有 200000，非常大）。

#include <stdio.h>
#include <string.h>

long long f[250];
char A[320000], B[250];

int main()
{
    long long ans = 0;
    int Alen, Blen, i, j;
    scanf("%s%s", A+1, B+1);
    Alen = strlen(A+1), Blen = strlen(B+1);
    for (i = 1; i <= Alen; ++i) {
        f[0] = i;
        for (j = Blen; j >= 1; --j)
            if (A[i] == B[j]) f[j] = f[j-1];
        ans += f[Blen];
    }
    printf("%lld
", ans);
    return 0;
}

#include <stdio.h>
#include <algorithm>
#include <string.h>

using namespace std;

const int _N = 120000;
const int INF = 1e9;

int A[_N], f[_N], X[_N], Y[_N], cnt[_N];

int main()
{
    int i, N, len;
    scanf("%d", &N);
    for (i = 1; i <= N; ++i)
        scanf("%d", &A[i]);
    f[len = 0] = -INF;
    for (i = 1; i <= N; ++i) {
        if (A[i] > f[len]) { f[++len] = A[i], X[i] = len; continue; }
        int p = lower_bound(f+1, f+1+len, A[i])-f;
        f[p] = A[i], X[i] = p;
    }
    printf("%d
", len);
    f[len = 0] = -INF;
    for (i = N; i >= 1; --i) {
        if (-A[i] > f[len]) { f[++len] = -A[i], Y[i] = len; continue; }
        int p = lower_bound(f+1, f+1+len, -A[i])-f;
        f[p] = -A[i], Y[i] = p;
    }
    for (i = 1; i <= N; ++i)
        if (X[i]+Y[i]-1 == len) ++cnt[X[i]];
    for (i = 1; i <= N; ++i)
        if (X[i]+Y[i]-1 == len && cnt[X[i]] == 1) printf("%d ", i);
    return 0;
}

#include <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

typedef long long ll;

const int _N = 55005;
const ll INF = 1e15;

struct edge {
    int v; ll w;
    edge(int v = 0, ll w = 0):
        v(v), w(w) { }
    bool operator < (edge const &tmp) const
    {
        return w > tmp.w;
    }
};

vector<edge> G[3][_N];
priority_queue<edge> Q;
queue<edge> Q2;
int N, M, beg1, end1, beg2, end2, ind[_N];
ll dis1[_N], dis2[_N], anti1[_N], anti2[_N];
bool mk[_N];

void Ins(int id, int x, int y, ll w) { G[id][x].push_back(edge(y, w)); return; }

void Dijkstra(int id, int beg, ll *dis)
{
    int i;
    for (i = 1; i <= N; ++i) dis[i] = INF;
    dis[beg] = 0;
    while (!Q.empty()) Q.pop();
    Q.push(edge(beg, dis[beg]));
    while (!Q.empty()) {
        int p = Q.top().v;
        vector<edge>::iterator it;
        if (Q.top().w != dis[p]) { Q.pop(); continue; }
        for (it = G[id][p].begin(); it != G[id][p].end(); ++it) {
            if (dis[it->v] <= dis[p] + it->w) continue;
            dis[it->v] = dis[p] + it->w;
            Q.push(edge(it->v, dis[it->v]));
        }
        Q.pop();
    }
    return ;

}

int main()
{
    int i, j;
    scanf("%d%d", &N, &M);
    for (i = 1; i <= M; ++i) {
        int x, y; ll w;
        scanf("%d%d%lld", &x, &y, &w);
        Ins(0, x, y, w), Ins(1, y, x, w);
    }
    scanf("%d%d%d%d", &beg1, &end1, &beg2, &end2);
    Dijkstra(0, beg1, dis1), Dijkstra(0, beg2, dis2);
    Dijkstra(1, end1, anti1), Dijkstra(1, end2, anti2);
    if (dis1[end1] >= INF || dis2[end2] >= INF) { printf("-1
"); return 0; }
    for (i = 1; i <= N; ++i)
        for (j = G[0][i].size()-1; j >= 0; --j) {
            edge p = G[0][i][j];
            if (dis1[i] >= INF || dis2[i] >= INF || anti1[p.v] >= INF || anti2[p.v] >= INF) continue;
            if (dis1[i]+p.w+anti1[p.v] == dis1[end1] && dis2[i]+p.w+anti2[p.v] == dis2[end2])
                Ins(2, i, p.v, p.w), ++ind[p.v];
        }
    for (i = 1; i <= N; ++i)
        if (!ind[i])
            Q2.push(edge(i, 1));//-------------------------
    ll ans = 0;
    while (!Q2.empty()) {
        edge p = Q2.front(); Q2.pop();
        ans = max(ans, p.w);
        for (int i = G[2][p.v].size()-1; i >= 0; --i) {
            int t = G[2][p.v][i].v;
            if (!--ind[t]) Q2.push(edge(t, p.w+1));
        }
    }
    printf("%lld
", ans);
    return 0;
}

A密码

时间限制 : 10000 MS   空间限制 : 165536 KB

评测说明 : 1s

问题描述

假发通过了不懈的努力，得到了将军家门锁的密码（一串小写英文字母）。但是假发被 十四和猩猩他们盯上了，所以假发需要把密码传递出去。因为假发不想十四他们发现几松门 前贴的小纸条就是将军家的密码，所以他加密了密码（新八：听起来有点诡异）。加密方法 如下：随机地，在密码中任意位置插入随机长度的小写字符串。 不过，假发相信银桑和他那么多年小学同学，一定能猜中密码是什么的（新八：银桑什 么时候成攮夷志士了！！！）。可是，写完了小纸条之后，假发觉得有点长，就想截去头和 尾各一段（可以为空），让剩下的中间那一段依然包含真～密码。想着想着，假发就想知道 有多少种可行方案。结果在沉迷于稿纸之际，假发被投进了狱门岛（新八：……）。于是， 就由你计算了。

输入格式

两行非空字符串，纯小写英文字母，第一行是加密后的密码，第二行是原密码。
第一行长度不超过 300000，第二行不超过 200。 

输出格式

一行，有多少种方案。注意：不剪也是一种方案。

样例输入 1

abcabcabc 
cba

样例输出 1

9

样例输入 2

abcabcabac 
cba

样例输出 2

18

提示

【样例1解释】 用(L,R)表示一种方案，其中L和R分别表示截去头和尾的长度。这9钟方案分别是 (0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)。 

B独立集

时间限制 : 20000 MS   空间限制 : 165536 KB

评测说明 : 1s

问题描述

输入格式

输入包含两行，第一行为 N，
第二行为 1 到 N 的一个全排列

输出格式

输出包含两行，第一行输出最大独立集的大小，第二行从小到大输出一定在最大独立集 的点的编号。 

样例输入 1

样例输出 1

样例输入 2

15
4 14 9 12 11 1 5 6 2 7 13 15 8 10 3

样例输出 2

6
7 8 10 

样例输入 3

3 
3 1 2

样例输出 3

2
2 3

提示

30%的数据满足 N<=16
60%的数据满足 N<=1,000
100%的数据满足 N<=100,000

 

C益智游戏

时间限制 : 10000 MS   空间限制 : 165536 KB

评测说明 : 1s

问题描述

小 P 和小 R 在玩一款益智游戏。游戏在一个正权有向图上进行。 小 P 控制的角色要从 A 点走最短路到 B 点，小 R 控制的角色要从 C 点走最短路到 D 点。 一个玩家每回合可以有两种选择，移动到一个相邻节点或者休息一回合。 假如在某一时刻，小 P 和小 R 在相同的节点上，那么可以得到一次特殊奖励，但是在每 个节点上最多只能得到一次。 求最多能获得多少次特殊奖励。 

输入格式

第一行两个整数 n，m 表示有向图的点数和边数。 接下来 m 行每行三个整数 xi，yi，li，表示从 xi到 yi有一条长度为 li的边。 最后一行四个整数 A，B，C，D，描述小 P 的起终点，小 R 的起终点。

输出格式

输出一个整数表示最多能获得多少次特殊奖励。若小 P 不能到达 B 点或者小 R 不能到达 D 点则输出-1。

样例输入

5 5 
1 2 1 
2 3 2 
3 4 4 
5 2 3 
5 3 5 
1 3 5 4

样例输出

2

提示

【数据规模】
对于 30%的数据，满足 n≤50
对于 60%的数据，满足 n≤1000，m≤5000 对于
100%的数据，满足 n≤50000，m≤200000，1≤li≤500000000