图论综合练习

开始刷的第一场图论专题

效率略低，但是好歹在秋假之前刷完了这一场了，理解果然变的更深了，要是还有时间刷就好了

Omkar and Last Class of Math

• CodeForces - 1372B

题意：1300的数论题，故意找的简单的数论题，数论起步一下吧，题面就是给定两数之和，求两数lcm最小值
思路：偶数就不说了，答案就是n/2,奇数就是暴力试一下能不能除尽3.5.7.9……之类的，能除尽答案就是剩下大的那个数
AC代码

#include <bits/stdc++.h>
using namespace std;
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        if(n%2==0){
            printf("%d %d\n",n/2,n/2);
        }
        else {
            int ans = 1;
            for(int i = 3;i*i <= n; i+=2){
                if(n%i==0){
                    ans = i;break;
                }
            }
            if(ans==1)printf("%d %d\n",1,n-1);
            else printf("%d %d\n",n/ans,n-n/ans);
        }
    }
}

Flight

• HDU - 3499

题意：就是给一个有向图，再给两个点，问最短路长度是多少，然后允许一条路径的某一条边权值减半

思路：
最短路+限制条件，是我找的分层图最短路的板子题，然后像这种的还有旅行商（分三个域），就直接在建两个图，然后分层图之间连一下权值减半的边，然后dijkstra就完了

AC代码

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn  = 2e6+5;
const int N = 2e5+5;
int n,m;
map<string,int>mp;
struct edge{
    int v,next,w;
}e[maxn];
int cnt = 0;
int head[N];
int vis[N];
void add(int u,int v,int w){
    e[cnt].v = v;
    e[cnt].w = w;
    e[cnt].next = head[u];
    head[u] = cnt++;
}
ll dis[N];
void inits(){
    for(int i = 0;i <= n * 2; i++){
        head[i] = -1;
        dis[i] = (1LL<<60);
        vis[i] = 0;
    }
    mp.clear();
    cnt = 0;
}
struct Node {
    int id;
    ll d;
    bool operator < (const Node &x)const{
        return d > x.d; 
    }
};
priority_queue<Node>q;
void dijskra(int s,int ed){
    while(!q.empty())q.pop();
    Node x = {s,0};
    dis[s] = 0;
    q.push(x);
    while(!q.empty()){
        Node now = q.top();
        q.pop();
        if(vis[now.id])continue;
        vis[now.id] = 1;
        for(int i = head[now.id];~i;i = e[i].next){
            int v = e[i].v;
            int w = e[i].w;
            if(dis[v] > dis[now.id] + w){
                dis[v] = dis[now.id] + w;
                Node nt = {v,dis[v]};
                q.push(nt);
            }
        }
    }
    if(dis[ed+n]>=(1LL<<55))printf("-1\n");
    else printf("%lld\n",dis[ed+n]);
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    while(cin>>n>>m){
        int ct = 1;
        inits();
        for(int i = 1 ;i <= m;i++){
            string a,b;
            cin>>a;
            if(mp.count(a) == 0){
                mp[a] = ct++;
            }
            cin>>b;
            if(mp.count(b) == 0){
                mp[b] = ct++;
            }
            ll x;cin>>x;
            add(mp[a],mp[b],x);
            add(mp[a]+n,mp[b]+n,x);
            add(mp[a],mp[b]+n,x/2);
        }
        string x,y;
        cin>>x>>y;
        dijskra(mp[x],mp[y]);
    }
}

Party

• HDU - 3062

题意：
n对夫妻被邀请参加一个聚会，因为场地的问题，每对夫妻中只有1人可以列席。在2n 个人中，某些人之间有着很大的矛盾（当然夫妻之间是没有矛盾的），有矛盾的2个人是不会同时出现在聚会上的。有没有可能会有n 个人同时列席？

思路：
2SAT板子题目，然后就是分两个域，第一个是在0-n表示妻子参加n-2n表示丈夫参加
然后注意建图
2SAT是按照离散数学命题和逆命题规律建立的，比如上题所说，如果我们0号和1号妻子之间有矛盾，那么我们推出的是如果选0号妻子，必选1号丈夫，如果选1号妻子，必选0号丈夫（互为逆否命题），然后关系是需要有传递型的，比如朋友关系就没有，如果我们选有传递性的或者逆命题等价原命题的，使用并查集。
然后可行解可以使用拓扑序维护，吧拓扑序较小的作为正解，然后拓扑序，（因为逆向建图），然后就是字典序最小就是dfs暴力解，这个下面说

ps:这个题多组样例，但是题目上没说，wa麻了

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
vector<int>g[maxn];
int dfn[maxn];
int ins[maxn];
int low[maxn];
int s[maxn],top = 0;
int num = 0;
int lis_nu = 0;
int tag[maxn];
void Tarjan(int x){
    dfn[x] = low[x] = ++num;
    s[++top] = x;
    ins[x] = 1;
    for(int i = 0;i<g[x].size();i++){
        int v = g[x][i];
        if(!dfn[v]){
            Tarjan(v);
            low[x] = min(low[v],low[x]);
        }
        else if(ins[v])low[x] = min(low[x],dfn[v]);
    }
    if(low[x]==dfn[x]){
        lis_nu++;
        int t;
        do{
            t = s[top--];
            ins[t] = 0;
            tag[t] = lis_nu;
        }while(t!=x);
    }
}
int n,m;
void inits(){
    for(int i = 0;i < n*2;i++){
        g[i].clear();
        dfn[i] = low[i] = ins[i] = 0;
    }
    top = 0;
    lis_nu = 0;
}
int main(){
    
    while(~scanf("%d%d",&n,&m)){
        inits();
        for(int i = 0;i < m;i++){
            int a1,a2,c1,c2;
            scanf("%d%d%d%d",&a1,&a2,&c1,&c2);
            if(c1==0&&c2==0){
                g[a1].push_back(a2+n);
                g[a2].push_back(a1+n);
            }
            else if(c1==0&&c2==1){
                g[a1].push_back(a2);
                g[a2+n].push_back(a1+n);
            }
            else if(c1==1&&c2==0){
                g[a1+n].push_back(a2+n);
                g[a2].push_back(a1);
            }
            else {
                g[a1+n].push_back(a2);
                g[a2+n].push_back(a1);
            }
        }
        for(int i = 0;i < n*2;i++){
            if(!dfn[i]){
                Tarjan(i);
            }
        }
        int flag = 0;
        for(int i = 0;i < n;i++){
            if(tag[i]==tag[i+n]){
                printf("NO\n");flag = 1; 
                break;
            }
        }
        if(!flag)printf("YES\n");
    }

    
}

Bracket Sequence

• CodeForces - 223A

题意：
输入一个字符串，输入这个字符串合法的一段子串，然后使得这个子串"["最多（合法指的是括号匹配合法）

思路：
模拟一下，开一个栈记录下标，类似括号匹配模拟，如果遇到和栈顶匹配的括号，就弹栈，然后如果没有，就入栈，然后记录每一个位置 匹配到的最左边合法的位置是多少（栈顶下表），然后记录每个位置能到达的最左边，统计“[”的前缀，然后在遍历一遍找最多的好了

AC代码

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int sum[maxn];
int ans[maxn];
int main(){
    string s;
    cin>>s;
    s = " " + s;
    stack<int>st;
    for(int i = 1; i < (int)s.size();i++){
        if(s[i]=='[')sum[i] = sum[i-1]+1;
        else sum[i] = sum[i-1] ;
    }
    st.push(0);
    for(int i = 1;i <= (int)s.size();i++){
        if(s[i]==']'){
            if(s[st.top()] == '['){
                st.pop();
                ans[i] = st.top();
            }
            else {
                st.push(i);
                ans[i] = i;
            }
        }
        else if(s[i]==')'){
            if(s[st.top()] == '('){
                st.pop();
                ans[i] = st.top();
            }
            else {
                st.push(i);
                ans[i] = i;
            }
        }
        else if(s[i]=='['||s[i]=='('){
            ans[i] = i;
            st.push(i);
        }
    }
    int mx = 0;
    int id = -1;
    for(int i = 1;i < (int)s.size();i++){
        // mx = max(mx,sum[i] - sum[ans[i]]);
        if(mx<=sum[i] - sum[ans[i]]){
            mx = sum[i] - sum[ans[i]];
            id = i;
        }
    }
    cout<<mx<<endl;
    for(int i = ans[id]+1;i <= id ;i++){
        printf("%c",s[i]);
    }
}

Peaceful Commission

• HDU - 1814

题意：就是说的字典序最下的2SAT，就是n个政党，然后每个政党的有2人，然后有仇视关系，问能否每个政党出一个人，凑一个会议

思路：
2SAT和上面思路一样，不过我们是字典序最小，那么我们只能选择dfs,dfs是一种暴力解法，复杂度$N^2$，然后就是暴力先搜小的，然后由于这里题目给的特殊性我们的两个域，分别表示为x和x^1成对变换，如果是0-n和n-2n，我们需要在开一个opp数组

AC代码
基本是模版，以后可以拿来用

#include <bits/stdc++.h>
using namespace std;
const int maxn = 26005;
vector<int>g[maxn];
int tag[maxn];
int vis[maxn];//记录这次搜索了那些点
int num = 0;
int n,m;
bool dfs(int x){
    if(tag[x^1])return false;
    if(tag[x])return true;
    vis[num++] = x;
    tag[x] = 1;
    for(int i = 0;i < (int)g[x].size();i++){
        int v = g[x][i];
        if(!dfs(v)){
            return false;
        }
    }
    return true;
}
bool _SAT(){
    for(int i = 0;i < 2*n; i+=2){
        if(!tag[i]&&!tag[i^1]){
            num = 0;
            if(!dfs(i)){
                while(num){
                    tag[vis[--num]] = 0;
                }
                if(!dfs(i^1))return false;
            }
        }
    }
    return true;
}

void inits(){
    for(int i = 0 ;i <= 2*n;i++){
        g[i].clear();
        tag[i] = 0;
        vis[i] = 0;
    }
}
int main(){
    
    while(~scanf("%d%d",&n,&m)){
        inits();
        for(int i = 0;i<m;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            a--;b--;
            g[a].push_back(b^1);
            g[b].push_back(a^1);
        }
        if(_SAT()){
            for(int i = 0; i < n*2;i+=2){
                if(tag[i]){
                    printf("%d\n",i+1);
                }
                else printf("%d\n",i+2);
            }
        }
        else {
            printf("NIE\n");
        }
    }
    

}

Garland

• CodeForces - 1286A

题意：
就是给一个序列，然后空出了一些位置（为0），问填什么数可以让序列相邻的x,x+1位置奇偶不同的数目最少
思路：开始以为是匹配题，结果是dp题……
记录状态需要三维，$dp[i][j][k]$表示到第i个位置，前面用了j个偶数，最后以为是偶数（或奇数）最小的答案是什么，可以维护所有状态，最后答案为$dp[n][n/2][0]$或$dp[n][n/2][1]$

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 105;
int a[maxn];
int dp[maxn][maxn][2];
int main(){
    int n;
    scanf("%d",&n);
    
    memset(dp,INF,sizeof dp);
    for(int i =1;i<=n;i++){
        scanf("%d",&a[i]);
        // dp[i][0][1] = dp[i][0][0] = 0;
    }
    dp[0][0][0] = dp[0][0][1] = 0;
    for(int i = 1;i<=n;i++){
        for(int j = 0;j <= n/2&&j<=i;j++){
            if(a[i]%2==0&&a[i]){
                if(j>0)dp[i][j][0] = min(dp[i-1][j-1][0],dp[i-1][j-1][1]+1);
            }
            else if(a[i]%2==1&&a[i]){
                dp[i][j][1] = min(dp[i-1][j][1],dp[i-1][j][0]+1);
            }
            else if(a[i]==0){
                dp[i][j][0] = min(dp[i-1][j-1][0],dp[i-1][j-1][1]+1);
                dp[i][j][1] = min(dp[i-1][j][1],dp[i-1][j][0]+1);
            }

        }
    }
    if(a[n]==0)cout<<min(dp[n][n/2][0],dp[n][n/2][1])<<endl;
    else if(a[n]%2==1)cout<<dp[n][n/2][1]<<endl;
    else cout<<dp[n][n/2][0]<<endl;
}

Chef Monocarp

• CodeForces - 1437C

题意：就是m个时刻，每个时刻选择一个物品，然后我们的答案累加物品的时长减该时刻，一个时刻只能选一个物品，然后问最小的代价是多少。

背包dp然后注意两点，$dp[i][j]$表示到第i个时刻，然后用0-j个之间的物品，然后答案最小是多少
优化掉第一维，然后就是需要排序，因为我们就是最小的背包dp是不需要排序的，因为我们这里的物品的价值是改变的，我们时间是从小往大转移，然后物品的时刻也需要从小往大排序，保证我们在i时刻选取的物品j是最优的。

Ac代码

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 405;
int a[maxn];
int dp[maxn];
int main(){
    int q;
    cin>>q;
    while(q--){
        int n;
        scanf("%d",&n);
        memset(dp,INF,sizeof dp);
        for(int i = 1;i<=n;i++){
            scanf("%d",&a[i]);
            // dp[0][i] = 0;
        }
        sort(a+1,a+n+1);
        dp[0] = 0;
        int ans = INF;
        for(int i = 1;i < maxn;i++){
            for(int j = n;j >= 1;j--){
                dp[j] = min(dp[j],dp[j-1] + abs(i-a[j]));
                // cout<<dp[i][j]<<" ";
            }
            // cout<<endl;
            ans = min(ans,dp[n]);
        }
        cout<<ans<<endl;
    }
}

其他注意事项：
dp背包的顺序是可改的，不过有简单和麻烦之分，然后就是dp最小值和最大值的区别在于初始化dp数组的值，（完全背包也是这样的）

然后还有一道01背包的例题

01背包求解组合最值问题
【题目描述】(Stone1.cpp/c/pas) Ural 1005

给出一堆魔法石的重量，问如何分成两堆，使得它们质量和之差最小，求出这个最小值。

直接dp数组维护可以到达的和，然后在，在遍历一遍就ok了