SDUT 2021 Summer Individual Contest - 6(for 20) A B C

SDUT 2021 Summer Individual Contest - 6

A - Min Difference

大意：从a和b数列分别取一个数字，求其差值的绝对值的最小值。
思路：

1. 做法A 分别排序，两个指针，每次while循环得到一个差值，使当前较小的数组的指针上移，直到一个出界
2. 做法B 用结构体或者pair类型储存一个数的值和它所在的a or b数组，排序并循环整个结构体数组（或者pair队列）如果两个数分别来自不同数组则求差值。

下面为做法A

/*
 * @Description: 
 * @Author: Kirie
 * @LastEditTime: 2021-08-10 13:30:17
 */
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ll long long
typedef pair<int, int> PII;

const int INF = 0x3f3f3f3f;
const int N = 2e5 + 7;

int a[N], b[N];

int main()
{
    int n, m;
    cin >> n >> m ;
    rep(i,1,n) 
        cin >> a[i];
    rep(i,1,m) 
        cin >> b[i];
    sort(a+1,a+1+n);
    sort(b+1,b+1+m);
    int i = 1, j = 1;
    int mn = INF;
    while(1) {
        int t = abs(a[i] - b[j]);
        if(t < mn) 
            mn = t;
        if(a[i] < b[j]) {
            i ++;
        } else {
            j ++;
        }
        if(i > n || j > m) {
            break;
        }
    }
    cout << mn << endl;
    return 0;
}

B - Querying Multiset

大意：对于一堆没有数字的球有如下三种操作，按照输入执行q次：

1. 添加一个数字到一个球上
2. 让当前全部球增加一个量
3. 取出当前值最小的球，并输出值

tips：简单了解优先队列：
头文件在queue里，内部通过堆的结构优化为从小到大（小根堆）或者从大到小（大根堆）的队列。虽然听着复杂但是其使用跟队列是一样的，并且方便。
声明函数根据排序方式分为两种（以存int类型队列举例）：

1. priority_queue<int, vector, greater > que;
2. priority_queue<int, vector, less > que;

可以注意到有三维：priority_queue< (1. 队列中元素的数据类型) , (2. 用于储存和访问队列元素的底层容器的类型) , (3. 比较规则) > 队列名。
需要注意的是最后两个“>”号中间必须要有空格！
队列常用操作：
que.push(x); // x先进
que.pop(); // 先出
que.top(); // 返回队头元素
que.empty(); // 如果队列为空返回true，否则false

思路：本题可以通过优先队列解

1. 队列内部存放当前小球数据的相对值（看后面再理解），这里都开long long类型最好。
2. 优先队列自动按照第数值进行排列（因为要取出最小球，这里用小根堆）。
3. 假如每次执行操作2都要更新当前数组的话，时间会起飞。思考一下，前面所有数都加其实相当于后面进去的数都减。
4. 读入x，实际存到队列x-sum(i)，实际上除了第一个数是本身以外，后面所有的数都是相对减去操作2得到的值
   取出x-sum(i)，实际输出x+(sum(j)-sum(i))，说明对于x这个数，它增加了sum(j)-sum(i)的大小。
   括号代表当时的序号，其中i是读入时的操作号，j是输出时的操作号

/*
 * @Description: 
 * @Author: Kirie
 * @LastEditTime: 2021-08-10 20:29:04
 */
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ll long long
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;

const int INF = 0x3f3f3f3f;
const int N = 2e5 + 7;

priority_queue <ll, vector <ll> , greater <ll> > que;

int main()
{
    int q;
    cin >> q;
    ll x;
    ll sum = 0;
    for(int i = 1;i <= q; i ++){
        int opt;
        cin >> opt;
        if(opt == 1) { // 入队空白球
            cin >> x;
            x -= sum;
            que.push(x);
        } else if(opt == 2){
            cin >> x;
            sum += x;
        } else {
            cout << que.top() + sum << endl;
            que.pop();
        }
    }
    return 0;
}

C - Safety Journey

大意：n座城市（1~n），原本是完全图，删去m座桥，一个人旅行k天，保证第一天和最后一天在城市1，其余时间每天都会从一个城市到达一个连通的城市。
思路：搜索会爆（瑞思拜搜索0v0）dp问题。观察可以设二维dp[i][j]，表示第i天达到城市j的方案数。可得状态转移方程为

f[i][j] = f[i - 1][1] + f[i - 1][2] + … + f[i - 1][n] - f[i - 1][ 不能到达的城市 ] - f[i-1][ j自己 ];

其中第一天可以到达城市1，方案数为1。
求第k天到达城市1，即f[k][1]。

需要用邻接表存图，内部所有元素最好都开long long

/*
 * @Description: 
 * @Author: Kirie
 * @LastEditTime: 2021-08-10 16:24:03
 */
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ll long long
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;

const int INF = 0x3f3f3f3f;
const int N = 1e4 + 7;
const int mod = 998244353; 

ll h[N], e[N], ne[N], idx, f[N][N];

void init(){
    idx = 0;
    mem(h,-1);
    mem(ne,0);
    mem(e,0);
    mem(f,0);
}

void add(ll a, ll b) {
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

int main()
{
    init();
    ll n, m, k, u, v;
    cin >> n >> m >> k;
    rep(i,1,m) {
        cin >> u >> v;
        add(u, v), add(v, u);    
    }
    f[0][1] = 1; // 第一天可以到达1
    for(ll i=1;i<=k;i++){ // i天
        ll sum=0;
        for(ll j=1;j<=n;j++) { // i-1天的总和
            sum += f[i-1][j];
        }
        for(ll j=1;j<=n;j++) { // 起点
            f[i][j] = sum - f[i-1][j]; // 前一天它本身不能到达自己
            for(ll kk = h[j] ; kk != -1 ; kk = ne[kk]) { // 终点
                f[i][j] -= f[i-1][e[kk]];
            }
            f[i][j] %= mod;
        }
    }
    cout << f[k][1] << endl;
    return 0;
}

/*
 *
 ?                        _oo0oo_
 !                       o8888888o
 ?                       88" . "88
 !                       (| = = |)
 ?                       0\  √ /0
 !                     ___/`---'\___
 ?                   .' \\|     |// '.
 !                  / \\|||  :  |||// \
 ?                 / _||||| -:- |||||- \
 !                |   | \\\  - /// |   |
 ?                | \_|  ''\---/''  |_/ |
 !                \  .-\__  '-'  ___/-. /
 ?              ___'. .'  /--.--\  `. .'___
 !           ."" '<  `.___\_<★>_/___.' >' "".
 ?          | | :  `- \`.;`\ _ /`;.`/ - ` : | |
 !          \  \ `_.   \_ __\ /__ _/   .-` /  /
 ?      =====`-.____`.___ \_____/___.-`___.-'=====
 !                        `=---='
 ? 
 * 
//                                                      
 * 
 todo   佛祖保佑 = 永不宕机 && 永无BUG && 不掉头发 = true
 */