【刷题】综合模拟2——2019浙大上机模拟（晴神）

A - next[i]

Problem Description

在字符串匹配的KMP算法中有一个重要的概念是next数组，求解它的过程让不少同学伤透了心。next数组的直接语义其实是：使“长度为L的前缀”与“长度为L的后缀”相同的最大L，且满足条件的前后缀不能是原字符串本身。

例如对字符串"ababa"来说，长度为1的前缀与后缀都是"a"，它们相同；长度为2的前缀与后缀分别是"ab"和"ba"，它们不相同；长度为3的前缀与后缀都是"aba"，它们相同；长度为4的前缀与后缀分别是"abab"和"baba"，它们不相同。因此对字符串"ababa"来说，使“长度为L的前缀”与“长度为L的后缀”相同的最大L是3。

现在我们把这个最大的L值称为原字符串S的next值。在此概念的基础上，对给定的字符串S，下标为从1到N，那么next[i]就是指子串S[1…i]的next值。

现在给定一个字符串，下标从1到N，然后给一个下标i，求next[i]。

Input

每个输入文件一组数据。

只有一行，输入一个仅由小写字母组成的长度为N（1<=N<=100）的字符串、与一个下标i（1<=i<=N）。

Output

一个整数，即next[i]。

Sample Input 1

ababa 5

Sample Output 1

3

Sample Input 2

ababab 4

Sample Output 2

2

Sample Input 3

ab 2

Sample Output 3

0

分析：掌握具体算法即可，算法详解见KMP算法

#include
using namespace std;
void buildNext(string str, int nt[]){
    int len = str.size();
    nt[0] = -1;
    int t = nt[0], j = 0;
    while(j < len - 1){
        if(t < 0 || str[j] == str[t]){
            nt[++j] = ++t;
        }else{
            t = nt[t];
        }
    }
}
int main(){
    int nt[110];
    string str;
    cin>>str;
    buildNext(str, nt);
    int index;
    cin>>index;
    cout<

B - 链表重排

Problem Description

给定一条单链表，将链表结点进行头尾交错重新排序，即如果一条单链表为 L1 -> L2 -> … -> L(n-1) -> Ln ，那么重新排序完的结果是 L1 -> Ln -> L2 -> L(n-1) -> L3 -> L(n-2) -> …

Input

每个输入文件中一组数据。

第一行给出结点的总个数N（0

Address Data Next

其中Address为结点地址（不足5位的高位用零填充至5位），Data为结点的数据域（绝对值不超过10^5的整数），Next为结点的指针域（即下一个结点的地址）。数据保证Address不等于-1。

Output

输出按题目要求重新排序后的单链表。第一行为重新排序后单链表上结点的个数、第一个结点的地址。

之后每行一个结点，输出格式与输入相同，结点输出顺序为单链表连接顺序。

Sample Input

5 11111
33333 0 44444
22222 2 33333
11111 5 22222
05689 8 -1
44444 6 05689

Sample Output

5 11111
11111 5 05689
05689 8 22222
22222 2 44444
44444 6 33333
33333 0 -1

分析：

1. 链表的长度要自己计算，不是所有的节点都会用到

2. 链表可能是空的

#include
using namespace std;
const int nmax = 100010;
int data[nmax], nt[nmax], lt[nmax];
int main(){
    int n, head;
    cin>>n>>head;
    for(int i = 0; i < n; i++){
        int addr;
        cin>>addr;
        cin>>data[addr]>>nt[addr];
    }
    int len = 0;
    while(head != -1){
        lt[len++] = head;
        head = nt[head];
    }
    vectorans;
    int i = 0, j = len - 1;
    while(i <= j){
        ans.push_back(lt[i++]);
        if(i < j)ans.push_back(lt[j--]);
    }
    if(ans.size() == 0){
        printf("0 -1");
        return 0;
    }
    printf("%d %05d\n", ans.size(), ans[0]);
    for(int i = 0; i < ans.size() - 1; ++i){
        printf("%05d %d %05d\n", ans[i], data[ans[i]], ans[i + 1]);
    }
    printf("%05d %d -1\n", ans.back(), data[ans.back()]);
    return 0;
}

C - 极大匹配

Problem Description

对给定的无向图G=(V,E)，如果边集E’满足：（1）E’是E的子集；（2）E’中的任意两条边都没有公共顶点，那么称边集E’为图G的一个匹配（Matching）。而如果往E’中增加任意一条在E中但不在E’中的边，都会导致E’不再是图G的匹配，那么称E’为图G的一个极大匹配（Maximal Matching）。
（以上定义引自https://en.wikipedia.org/wiki/Matching_(graph_theory)）

根据上面的定义，请判断一些给定的边集是否是给定的无向图的极大匹配。

Input

每个输入文件一组数据。

第一行两个整数N、M（1<=N<=1000, 0<=M<=N*(N-1)/2），表示顶点数和边数，假设所有顶点的编号为1到N。

接下来M行，每行两个正整数u、v（1<=u,v<=N, u!=v），表示一条边的两个端点编号。

然后一个正整数K（K<=10），表示查询个数。

接下来为K个查询，每个查询第一行为一个正整数L，表示待查询边集的边数，接下来L行每行两个正整数，表示一条边的两个端点编号。数据保证每个查询中相同的边只会出现一次，且所有边都在图中存在。

Output

每个查询输出一行，如果给定的边集是极大匹配，那么输出Yes；如果它是匹配但不是极大匹配，那么输出Not Maximal；如果不是匹配，那么输出Not a Matching。

Sample Input

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

Sample Output

Yes
Not Maximal
Not a Matching
Yes

#include
using namespace std;
const int nmax = 1010;
bool vis[nmax], G[nmax][nmax], tempG[nmax][nmax];
struct node{
    int u, v;
};
int main(){
    int n, m, K, L;
    vectorE;
    cin>>n>>m;
    fill(G[0], G[0] + nmax * nmax, false);
    for(int i = 0; i < m; ++i){
        int u, v;
        cin>>u>>v;
        G[u][v] = G[v][u]  =true;
        E.push_back({u, v});
    }
    cin>>K;
    for(int i  =0; i < K; ++i){
        vectortempE;
        fill(vis, vis + nmax, false);
        fill(tempG[0], tempG[0] + nmax * nmax, false);
        cin>>L;
        bool flag = true;
        for(int j = 0; j < L; ++j){
            int u, v;
            cin>>u>>v;
            if(G[u][v] == false)flag = false;
            if(vis[u] == true || vis[v] == true)flag = false;
            tempG[u][v] = tempG[v][u] = true;
            tempE.push_back({u, v});
            vis[u] = vis[v] = true;
        }
        if(flag == false)printf("Not a Matching\n");
        else{
            for(int j = 0; j < E.size(); ++j){
                int u = E[j].u, v = E[j].v;
                if(tempG[u][v] == false){
                    if(vis[u] == false && vis[v] == false){
                        flag = false;
                        break;
                    }
                }
            }
            if(flag == true)printf("Yes\n");
            else printf("Not Maximal\n");
        }
    }
    return 0;
}

D - 关键路径

Problem Description

给定一个有N个顶点、M条边的有向图，顶点下标为从1到N，每条边都有边权。判断这个有向图是否是有向无环图，如果是的话，请处理K个查询，每个查询为图中的一条边，求这条边的最早发生时间和最晚发生时间。最后再输出图中的所有关键路径。

Input

每个输入文件中一组数据。

第一行为两个整数N、M，表示有向无环图的顶点数和边数（1<=N<=1000, 0<=M<=N*(N-1)），顶点编号为从1到N。

接下来M行，每行为三个正整数u、v、w（1<=u,v<=N,0

然后是一个正整数K（1<=K<=1000），表示查询个数。

接着是K行，每行为两个正整数u、v，分别表示查询边的起点和终点。数据保证查询边一定是图上存在的边。

Output

如果给出的图不是有向无环图，那么在一行里输出NO，后面的查询结果和关键路径均不需要输出；

如果给出的图是有向无环图，那么在一行里输出YES，接着输出下面的内容：

每个查询一行，输出查询边的最早发生时间和最晚发生时间；

之后一行输出一个整数：关键路径上的边权之和；

最后若干行输出所有关键路径，每行表示其中一条，格式为用->连接的顶点编号。注意，如果有两条关键路径a[1]->a[2]->…->a[k]->a[k+1]->…与b[1]->b[2]->…->b[k]->[k+1]->…，满足a[1]==b[1]、a[2]==b[2]、…、a[k]==b[k]、a[k+1]

Sample Input 1

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

Sample Output 1

YES
0 0
3 4
5
1->3->4
1->4

Sample Input 2

3 3
1 2 3
2 3 1
3 2 2
2
1 2
2 3

Sample Output 2

NO

分析：

1.多个有向图

2.多起点、多汇点

3.图中存在孤立点，此时入度也为0

求关键路径时，将存关键路径上的边而非关键活动，使用邻接表而非邻接矩阵

#include
using namespace std;
const int nmax = 1010;
struct node{
    int v, w;
};
vectorG[nmax];
vectoractivity[nmax];
int n, m, inDeg[nmax] = {0}, inDegOrigin[nmax] = {0};
int ve[nmax], vl[nmax];
int e[nmax][nmax], l[nmax][nmax];
stacktopOrder;
bool topologicalSort(){
    queueq;
    for(int i = 1; i <= n; ++i){
        if(inDeg[i] == 0)q.push(i);
    }
    while(!q.empty()){
        int u = q.front();
        q.pop();
        topOrder.push(u);
        for(int i = 0; i < G[u].size(); ++i){
            int v = G[u][i].v;
            inDeg[v]--;
            if(inDeg[v] == 0)q.push(v);
            ve[v] = max(ve[v], ve[u] + G[u][i].w);
        }
    }
    if(topOrder.size() == n)return true;
    else return false;
}
int criticalPath(){
    fill(ve, ve + nmax, 0);
    if(topologicalSort() == false)return -1;
    int maxLen = -1;
    for(int i = 1; i <= n; ++i){
        if(ve[i] > maxLen)maxLen = ve[i];
    }
    fill(vl, vl + nmax, maxLen);
    while(!topOrder.empty()){
        int u = topOrder.top();
        topOrder.pop();
        for(int i = 0; i < G[u].size(); ++i){
            int v = G[u][i].v;
            vl[u] = min(vl[u], vl[v] - G[u][i].w);
        }
    }
    for(int u = 1; u <= n; ++u){
        for(int i = 0; i < G[u].size(); ++i){
            int v = G[u][i].v, w = G[u][i].w;
            e[u][v] = ve[u];
            l[u][v] = vl[v] - w;
            if(e[u][v] == l[u][v])activity[u].push_back(v);
        }
    }
    return maxLen;
}
vectorpath;
void dfs(int u){
    if(activity[u].size() == 0){
        path.push_back(u);
        int flag = 0;
        for(int x : path){
            if(flag == 1)printf("->");
            printf("%d", x);
            flag = 1;
        }
        printf("\n");
        path.pop_back();
        return;
    }
    path.push_back(u);
    sort(activity[u].begin(), activity[u].end());
    for(int x : activity[u]){
        dfs(x);
    }
    path.pop_back();
}
int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i < m; ++i){
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back({v, w});
        inDeg[v]++;
        inDegOrigin[v]++;
    }
    int maxLen = criticalPath();
    if(maxLen == -1)printf("NO\n");
    else{
        printf("YES\n");
        int k;
        scanf("%d", &k);
        for(int i = 0; i < k; ++i){
            int u, v;
            scanf("%d%d", &u, &v);
            printf("%d %d\n", e[u][v], l[u][v]);
        }
        printf("%d\n", maxLen);
        for(int i =1; i <= n; ++i){
            if(inDegOrigin[i] == 0 && activity[i].size() != 0)dfs(i);
        }
    }
    return 0;
}