其他分享
首页 > 其他分享> > 2019-2020 ACM-ICPC Pacific Northwest Regional Contest (Div. 1)

2019-2020 ACM-ICPC Pacific Northwest Regional Contest (Div. 1)

作者:互联网

2019-2020 ACM-ICPC Pacific Northwest Regional Contest (Div. 1)

文章目录

A Radio Prize

大意:

求出一颗树上每个点到其他点的距离的和,两个点之间的距离定义为两个点的权值和乘上路径权值和

思路:

明显是换根DP,不过写的时候写了好久…

将所求拆成两个数:这个点的权值乘路径权值和+目标点的权值乘路径权值和,这样就可以维护了,换根的时候求出父节点到这个节点的贡献即可

#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 5;
typedef long long LL;
#define int LL

int n, a[N], sumv[N];
int SUMW = 0;
int sumV[N];
vector<pair<int, int>> mp[N];
int dp[N], dis[N][2], sz[N];
int res[N];
void dfs1(int now, int fa) {
    sumv[now] = a[now];
    sz[now] = 1;
    for (int i = 0; i < mp[now].size(); i++) {
        int ne = mp[now][i].first, w = mp[now][i].second;
        if (ne == fa) continue;
        dfs1(ne, now);
        sz[now] += sz[ne];                    //子节点数量
        dp[now] += dp[ne] + w * sumv[ne];  //子节点的贡献
        sumv[now] += sumv[ne];                //子节点权值和
        dis[now][0] += dis[ne][0] + w * sz[ne];  //子节点距离和
    }
}

void dfs2(int now, int fa) {
    for (int i = 0; i < mp[now].size(); i++) {
        int ne = mp[now][i].first, w = mp[now][i].second;
        if (ne == fa) continue;

        dis[ne][1] = dis[now][1] - w * sz[ne] + w * (n - sz[ne]);
        res[ne] = dp[ne] + dis[ne][1] * a[ne] + res[now] -
                  dis[now][1] * a[now] - (dp[ne] + w * sumv[ne]) +
                  w * (SUMW - sumv[ne]);
        dfs2(ne, now);
    }
}

signed main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i],SUMW += a[i];
    for (int i = 1; i <= n - 1; i++) {
        int x, y, w;
        cin >> x >> y >> w;
        
        mp[x].push_back({y, w}), mp[y].push_back({x, w});
    }
    dfs1(1, 0);
    res[1] = dp[1] + dis[1][0] * a[1];
    dis[1][1] = dis[1][0];
    dfs2(1, 0);
    for (int i = 1; i <= n; i++) cout << res[i] << endl;
    return 0;
}

B Perfect Flush

大意:

给出n个数,n个数都是由1到k的数组成,现在要从里面找到一个字典序最小的1到k的全排列

思路:

用栈去维护,如果当前栈顶的数字在后面还会出现,且比当前要入栈的数字大,那么就弹栈

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
int const MAXN = 2e5 + 10;
int n, k;
int a[MAXN];
int pos[MAXN];
stack<int> sta;
int vis[MAXN];
vector<int> ans;
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n >> k;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        pos[a[i]] = i;
    }
    for (int i = 1; i <= n; i++) {
        if (vis[a[i]]) continue;
        while (sta.size()) {
            int t = sta.top();
            if (a[i] >= t) break;
            if (pos[t] < i) break;
            vis[t] = 0;
            sta.pop();
        }
        sta.push(a[i]);
        vis[a[i]] = 1;
    }
    while (sta.size()) {
        //cout << sta.top() << " ";
        ans.push_back(sta.top());
        sta.pop();
    }
    for (int i = ans.size() - 1; i >= 0; i--) {
        cout << ans[i] << " ";
    }
    return 0;
}

C Coloring Contention

大意:

给出一个无向图,Bob要从1号点走到n号点,Alice现在要给每条边染色,他可以染红色或者蓝色,Alice想让Bob经过的路径中颜色变换次数最多,Bob则想让自己经过的颜色变换次数最少,问Alice能让Bob经过的颜色变换次数最多是多少次

思路:

直接bfs,求出1到n的最短路,然后最短路径-1即可

#include <bits/stdc++.h>

#define int long long
#define debug(x) cout << #x << " = " << x << endl;
using namespace std;

int const MAXN = 2e5 + 10, MAXM = MAXN * 2;
int n, m, T, e[MAXN], ne[MAXM], h[MAXN], idx, st[MAXN], dis[MAXN];
queue<int> q;

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

void bfs(int S) {
    q.push(S);
    st[S] = 1;
    while(q.size()) {
        auto t = q.front();
        q.pop();

        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (st[j]) continue;
            st[j] = 1;
            dis[j] = dis[t] + 1;
            q.push(j);
        }
    }
}

signed main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 1, a, b; i <= m; ++i) {
        cin >> a >> b;
        add(a, b), add(b, a);
    }
    bfs(1);
    cout << max((long long)0, dis[n] - 1);
    return 0;
}

D Dividing by Two

大意:

给出两个点A和B,现在每次操作可以将A除以2(此时A必须为偶数),或者将A加1,问最少多少次操作可以将A变换为B

思路:

当A小于B时,肯定只能不停+1

当A大于B时,首先将其变换到B到2*B 的区间,然后判断先除后减还是先减后除

#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 5;
typedef long long LL;
#define int LL
int a, b;
signed main() {
    cin >> a >> b;
    if (a <= b) {
        cout << b - a << endl;
    } else {
        int res = 0;
        swap(a, b);
        while (1) {
            if (b >= a && b <= 2 * a) {
                int tmp;
                if (b % 2 == 0)
                    tmp = min(2 * a - b + 1, 1 + a - b / 2);
                else
                    tmp = min(2 * a - b + 1, 2 + a - (b + 1) / 2);
                cout << res + tmp << endl;
                return 0;
            }
            if(b%2==0){
                res++;
                b /= 2;
            }
            else{
                res++;
                b++;
            }
        }
    }
    return 0;
}

E Rainbow Strings

大意:

给定一个长度为n字符串,要求从中选择一些子序列,使得子序列中每种字符只出现一次,问这样的子序列有多少个?

思路:

可以计算一下原来的字符串中每个字符出现的次数,那么子序列就是每次从不同的字符串挑选出一个或者不选的方案,即(c[0] + 1) * (c[1] + 1) * (c[2] + 1) * … * (c[n] + 1)

代码:

#include <bits/stdc++.h>

using namespace std;

#define int long long
int const MAXN = 2e5 + 10;
int const mod = 11092019;
int n, m, T;
int num[MAXN];
signed main() {
    string s;
    cin >> s;
    for (int i = 0; i < s.size(); i++) {
        num[s[i] - 'a']++;
    }
    int ans = 1;
    for (int i = 0; i < 26; i++) {
        ans = ans * (num[i] + 1) % mod;
    }
    cout << ans;
    return 0;
}

I Error Correction

题意: 给定n个字符串,每个字符串中不存在重复出现的字符。现在要从这n个字符串中选择一个子集,使得子集中不存在两个字符串仅仅交换2个字符就会完全相同的情况。问这样的子集最大是多大。 1 < = n < = 500 1<=n<=500 1<=n<=500

题解: 最大独立集。对于每个字符串看作一个点,如果2个字符串通过交换2个字符会相同,那么连一条边,那么就是找到一个最大的独立集。那么答案就是n - 最大匹配数目。

代码:

#include <bits/stdc++.h>

#define int long long
#define debug(x) cout << #x << " = " << x << endl;
using namespace std;

int const MAXN = 5e2 + 10;
int n, m, T, g[MAXN][MAXN], st[MAXN], match[MAXN];
string s[1000];

int check(int x, int y) {
    string s1 = s[x], s2 = s[y];
    int len = s1.size();
    int cnt = 0;
    for (int i = 0; i < len; ++i) {
        if (s1[i] != s2[i]) cnt++;
    }
    return cnt == 2;
}

bool find(int x) {
    for (int i = 1; i <= n; ++i) {
        if (!g[x][i]) continue;
        if (!st[i]) {
            st[i] = 1;
            if (!match[i] || find(match[i])) {
                match[i] = x;
                return true;
            }
        }
    }
    return false;
}

int hungary() {
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
        memset(st, 0, sizeof st);
        if (find(i)) ans++;
    }
    return ans;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> s[i];
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (i != j && check(i, j)) g[i][j] = g[j][i] = 1;
        }
    }

    cout << n - hungary() / 2;

    return 0;
}

/*
6
abc
acb
cab
cba
bac
bca

11
alerts
alters
artels
estral
laster
ratels
salter
slater
staler
stelar
talers

6
ates
east
eats
etas
sate
teas

*/

J Interstellar Travel

大意:

给出n个点,每个点都有三个属性T S A,每个点的贡献 m a x ( 0 , T i − s i ⋅ d i s t ( a i , a ) ) max(0,Ti−si·dist(ai,a)) max(0,Ti−si⋅dist(ai,a))

a为飞船飞行的角度,所以对于每个飞行角度,n个点的总贡献T是一定的,现在要求求出最大的T

思路:

据说正解是求出函数关系式,不过写了一发模拟退火+卡时过了…

#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 5;
typedef long long LL;
int n;
long double t[N], s[N], a[N];
const long double eps = 1e-8L;
const long double pi = acos(-1.0L);
int sgn(long double x) {
    if (fabs(x) < eps) return 0;
    if (x < 0)
        return -1;
    else
        return 1;
}
long double res = 0;
long double getsum(long double x) {
    long double re = 0;
    for (int i = 0; i < n; i++) {
        long double dis = fabs(x - a[i]);
        if (sgn(dis-pi) >= 0) dis=2.0L*pi-dis;
        re += max(0.0L, t[i] - s[i] * dis);
    }
    res = max(res, re);
    return re;
}

long double rand(long double l, long double r) {
    return (long double)rand() / RAND_MAX * (r - l) + l;
};

void sa() {
    long double p = rand(0.0L, 2.0L * pi);
    for (long double t = 2.0L * pi; t > 1e-8L; t *= 0.99L) {
        long double np = rand(max(0.0L,p - t), min(2.0L*pi,p + t));
        long double dt = getsum(np) - getsum(p);
        if (exp(dt / t) > rand(0, 1)) {
            p = np;
        }
    }
}

int main() {
    cin >> n;
    srand((unsigned)time(NULL));
    for (int i = 0; i < n; i++) {
        cin >> t[i] >> s[i] >> a[i];
    }
    while ((double)clock() / CLOCKS_PER_SEC < 3.0) sa();
    printf("%0.7Lf\n", res);
    return 0;
}

K.Computer Cache

题意: 给你n个空位 m个数据集 和q个查询 一开始所有空位数据都是0,每个数据集都有一些数,接下来有3种操作
1 i p 就是把第i个数据集覆盖再从p开始的空位上 ,保证位置合法
2 p 把第p个位置的数据打出来
3 i l r 把第i个数据集 从l位置到r位置的所有数据+1 (之后要mod256)

题解: 线段树+结构体维护。线段树上维护当前这个点进行的哪一种操作,然后维护一个结构体数组记录每次操作修改的起始位置,操作的处理长度,这些操作的懒标记。每次查询的时候只需要去线段树上查询下需要进行哪些操作,然后再去结构体数组里面找即可。

代码:

L Carry Cam Failure

大意:

定义不进位计算为无论对于加法还是乘法,所有的进位全部不计算。现在给你N,要求判断是否存在a,使得a * a = N。如果不存在,那么打印-1

思路:

模拟题。直接模拟每一位出现的情况,然后剪枝。每次的情况最多为2,复杂度为: O ( 2 n / 2 ) O(2^{n/2}) O(2n/2)

代码:

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
int const MAXN = 30;
int n, m, T;
string s;
int flag;
int pos;
int bit[MAXN];
int need[MAXN];
int sum[MAXN];
bool check(int k) {
    if (k == pos - 1 && bit[k] * bit[k] % 10 == need[k * 2]) return 1;
    if (k != pos - 1 && (sum[k + pos - 1] + bit[k] * bit[pos - 1] * 2) % 10 ==
                            need[k + pos - 1])
        return 1;
    return 0;
}
void dfs(int k) {
    // 搜索到头,扫一遍与输入比较
    if (k == -1) {
        flag = 1;
        for (int i = pos - 1; i >= 0; i--) {
            if (sum[i] % 10 != need[i]) {
                flag = 0;
                return;
            }
        }
        return;
    }
    if (flag) return;
    for (int i = 0; i < 10; i++) {
        if (flag) return;
        bit[k] = i;
        if (check(k)) {
            for (int j = pos - 1; j > k; j--)
                sum[j + k] += 2 * (bit[k] * bit[j]) % 10;
            sum[2 * k] += bit[k] * bit[k] % 10;
            dfs(k - 1);
            if (flag) return;
            for (int j = pos - 1; j > k; j--)
                sum[j + k] -= 2 * (bit[k] * bit[j]) % 10;
            sum[2 * k] -= bit[k] * bit[k] % 10;
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> s;
    int len = s.size();
    if (len % 2 == 0) return puts("-1"), 0;
    for (int i = 0; i < len; i++) need[i] = s[len - i - 1] - '0';
    pos = (len + 1) / 2;
    dfs(pos - 1);
    if (flag) {
        for (int i = pos - 1; i >= 0; i--) cout << bit[i];
    } else
        puts("-1");
    return 0;
}

/*
6
149
123476544
15
*/

M Maze Connect

大意:

给定一个迷宫网格,每个字符为"\", “/”, “.”。问你这个迷宫网格中有多少个简单环。

样例解释如下:

4 4
/\..
\.\.
.\/\
..\/

这样是2个环

思路:

dfs找简单环,每次走过就打个标记,遇到打过标记的点就说明找到了环。然后每次dfs找到的环除以2就是找到的环数目

代码:

#include <bits/stdc++.h>

#define int long long
using namespace std;

int const MAXN = 1e3 + 10, pMAXN = MAXN * MAXN, pMAXM = pMAXN * 4 * 2;
int n, m, T, e[pMAXM], ne[pMAXM], h[pMAXN], idx, vis[pMAXN], res, tmp;
char s[MAXN][MAXN];

int get(int x, int y) {
    return x * (m + 1) + y;
}

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

void dfs(int u, int fa) {
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == fa) continue;
        if (vis[j] == 1) {
            tmp ++;
            continue;
        }
        vis[j] = 1;
        dfs(j, u);
    }
    return;
}

signed main() {
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < n; ++i) scanf("%s", s[i]);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (s[i][j] == '/') add(get(i + 1, j), get(i, j + 1)), add(get(i, j + 1), get(i + 1, j));
            if (s[i][j] == '\\') add(get(i, j), get(i + 1, j + 1)), add(get(i + 1, j + 1), get(i, j));
        }   
    }

    for (int i = 0; i <= n; ++i) {
        for (int j = 0; j <= m; ++j) {
            if (vis[get(i, j)]) continue;
            vis[get(i, j)] = 1;
            tmp = 0;
            dfs(get(i, j), -1);
            res += tmp / 2;
        }
    }
    cout << res;

    return 0;
}

标签:return,Contest,int,Regional,ne,long,++,ACM,now
来源: https://blog.csdn.net/m0_49959202/article/details/114992490