2021/8/31(并查集pro

145. 超市

里有 N 件商品，每件商品都有利润 pi 和过期时间 di，每天只能卖一件商品，过期商品不能再卖。

求合理安排每天卖的商品的情况下，可以得到的最大收益是多少。

输入格式
输入包含多组测试用例。

每组测试用例，以输入整数 N 开始，接下来输入 N 对 pi 和 di，分别代表第 i 件商品的利润和过期时间。

在输入中，数据之间可以自由穿插任意个空格或空行，输入至文件结尾时终止输入，保证数据正确。

用一个小根堆来维护在x天卖x件商品的货物集合，
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
int n;
typedef pair<int, int> PII;

signed main()
{
    while(scanf("%d",&n)!=-1){
        vector<PII>huo(n);
        for(int i=0;i<n;i++)cin>>huo[i].second>>huo[i].first;
        priority_queue<int,vector<int>,greater<int>>heap;
        sort(huo.begin(),huo.end());
        for(int i=0;i<n;i++){
            int v=huo[i].second;
            int d=huo[i].first;
            heap.push(v);
            if(heap.size()>d)heap.pop();
        }
        long long ans=0;
        while(heap.size()){
            ans+=heap.top();
            heap.pop();
        }
        cout<<ans<<'\n';
    }
}

---

这道题也可以用链表式并查集做

#include <iostream>
#include <cstring>
#include <algorithm>
#define money first
#define day second
using namespace std;
const int N = 1e5;
typedef pair<int, int> PII;

int p[N],n;
int find(int x){
    if(x==p[x])return x;
    else return p[x]=find(p[x]);
}
signed main(){
    while(scanf("%d",&n)!=-1){
        vector<PII>huo(n);
        int maxday=0;
        int ans=0;
        for(int i=0;i<n;i++){cin>>huo[i].money>>huo[i].day;maxday=max(maxday,huo[i].day);}
        //按照货品的价值从大到小排列，从而保证答案的正确性
        //意思就是说越贵的商品越要优先卖出去
        sort(huo.begin(),huo.end());
        reverse(huo.begin(),huo.end());
        
        //初始化并查集，这个表示保质期为i的物品可以插在第i天卖
        for(int i=0;i<=maxday;i++)p[i]=i;
        
        for(auto t:huo){
            int v=t.money;
            int d=find(t.day);//我的保质期为i，现在找到我的可以卖的位置p【i】
            if(d>=1){
                ans+=v;
                p[d]=d-1;//插到我的前面一天去
            }
        }
        cout<<ans<<'\n';
    }
}

---

237. 程序自动分析

在实现程序自动分析的过程中,常常需要判定一些约束条件是否能被同时满足。

考虑一个约束满足问题的简化版本：假设x1,x2,x3,…x1,x2,x3,…代表程序中出现的变量，给定n个形如xi=xjxi=xj或xi≠xjxi≠xj的变量相等/不等的约束条件，请判定是否可以分别为每一个变量赋予恰当的值，使得上述所有约束条件同时被满足。

例如，一个问题中的约束条件为：x1=x2，x2=x3，x3=x4，x1≠x4x1=x2，x2=x3，x3=x4，x1≠x4，这些约束条件显然是不可能同时被满足的，因此这个问题应判定为不可被满足。

现在给出一些约束满足问题，请分别对它们进行判定。

输入格式
输入文件的第1行包含1个正整数tt，表示需要判定的问题个数，注意这些问题之间是相互独立的。

对于每个问题，包含若干行：

第1行包含1个正整数nn，表示该问题中需要被满足的约束条件个数。

接下来nn行，每行包括3个整数i,j,ei,j,e，描述1个相等/不等的约束条件，相邻整数之间用单个空格隔开。若e=1e=1，则该约束条件为xi=xjxi=xj；若e=0e=0，则该约束条件为xi≠xjxi≠xj。

输出格式
输出文件包括tt行。

输出文件的第k行输出一个字符串“YES”或者“NO”（不包含引号，字母全部大写），“YES”表示输入中的第k个问题判定为可以被满足，“NO”表示不可被满足。

数据范围
1≤n≤10000001≤n≤1000000
1≤i,j≤1000000000

作者：秦淮岸灯火阑珊
链接：https://www.acwing.com/solution/content/1004/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
//i，j很大但是查询很小，所以我们要离散化
//离散化如果需要保持排序的话（x<y则get(x)<get(y) )
//那么就要用vector排序判重加二分
//如果不需要保持相对关系的话就直接用哈希表map
const int N = 1e6+10;
int p[N],idx,T,n;
unordered_map<int,int>mp;
struct query{
    int a;
    int b;
    int c;
}q[N];

int find(int x){
    if(x==p[x])return x;
    else return p[x]=find(p[x]);
}

int get(int x){
    if(!mp.count(x))mp[x]=++idx;
    return mp[x];
}

void init(){
    mp.clear();
    idx=0;
    for(int i=0;i<N;i++)p[i]=i;
}
void solve(){
    cin>>n;
    init();
    for(int i=0;i<n;i++){
        int a,b,c;
        cin>>a>>b>>c;
        q[i]={get(a),get(b),c};
    }
    //先把所有相等的关系合并到一个个集合里面去
    //这一步对应并查集的合并操作
    for(int i=0;i<n;i++){
        auto t=q[i];
        if(t.c==1){
            //cout<<t.a<<" = "<<t.b<<endl;
            int a=find(t.a);
            int b=find(t.b);
            p[a]=b;
        }
    }
    //合并完后看看是否存在集合里面的两个元素不相等的状况
    //这一步对应并查集的查询操作
    int conflit=0;
    for(int i=0;i<n;i++){
        auto t=q[i];
        if(t.c==0){
            //cout<<t.a<<" != "<<t.b<<endl;
            int a=find(t.a);
            int b=find(t.b);
            if(a==b){
                puts("NO");
                conflit=1;
                break;
            }
        }
    }
    if(!conflit)puts("YES");
    
}

signed main(){
    cin>>T;
    while(T--)solve();
}

什么题目要用到并查集?那就是具有非常明显的传递关系的题目,或者说并查集擅长动态维护许多具有传递性的关系,能在无向图中维护节点之间的连通性.
这道题目明显就有两个关系变量相等的约束条件和不相等的约束条件.所以说,我们就将相等的约束条件,转化为将两个变量合并到一个集合中.
那么当相等约束条件全部执行完后,记住是全部执行完毕后,我们再去看不相等约束条件,如果说发现不相等的两个变量在同一个集合,那么就是不满足问题输出NO.如果都满足了,那么就是YES!

---

238. 银河英雄传说

有一个划分为 N 列的星际战场，各列依次编号为 1,2,…,N。

有 N 艘战舰，也依次编号为 1,2,…,N，其中第 i 号战舰处于第 i 列。

有 T 条指令，每条指令格式为以下两种之一：

M i j，表示让第 i 号战舰所在列的全部战舰保持原有顺序，接在第 j 号战舰所在列的尾部。
C i j，表示询问第 i 号战舰与第 j 号战舰当前是否处于同一列中，如果在同一列中，它们之间间隔了多少艘战舰。
现在需要你编写一个程序，处理一系列的指令。

输入格式
第一行包含整数 T，表示共有 T 条指令。

接下来 T 行，每行一个指令，指令有两种形式：M i j 或 C i j。

其中 M 和 C 为大写字母表示指令类型，i 和 j 为整数，表示指令涉及的战舰编号。

输出格式
你的程序应当依次对输入的每一条指令进行分析和处理：

如果是 M i j 形式，则表示舰队排列发生了变化，你的程序要注意到这一点，但是不要输出任何信息；

如果是 C i j 形式，你的程序要输出一行，仅包含一个整数，表示在同一列上，第 i 号战舰与第 j 号战舰之间布置的战舰数目，如果第 i 号战舰与第 j 号战舰当前不在同一列上，则输出 −1。

数据范围
N≤30000,T≤500000

#include<bits/stdc++.h>
#define size s
using namespace std;
int T;
const int N = 30001;
int p[N];
int size[N];
int d[N];
void init(){for(int i=0;i<N;i++)p[i]=i,size[i]=1;}
int find(int x){
    if(p[x]==x)return x;
    else {
        int t=find(p[x]);
        d[x]+=d[p[x]];
        return p[x]=t;
    }
}
void merge(int a,int b){
    a=find(a);
    b=find(b);
    p[a]=b;
    d[a]=s[b];
    s[b]+=s[a];
    //我们在merge和query之前都会先find
    //这就保证了merge的后三句有效
}
void query(int a,int b){
    int pa=find(a);
    int pb=find(b);
    if(pa==pb)cout<<max(0,abs(d[a]-d[b])-1)<<endl;
    else puts("-1");
}
signed main(){
    init();
    cin>>T;
    while(T--){
        char c;
        int x,y;
        cin>>c>>x>>y;
        if(c=='M')merge(x,y);
        else query(x,y);
    }
}

---

---

---

---

---

---

---