ACM ICPC, Damascus University Collegiate Programming Contest(2018) Solution

A：Martadella Stikes Again

水。

#include <bits/stdc++.h>

using namespace std;

#define ll long long

int t;
ll R, r;

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld%lld", &R, &r);
        if (R * R > 2ll * r * r)
            puts("1");
        else
            puts("2");
    }
    return 0;
}

B：Amer and Graphs

题意：给出n条边，连续选k条边，(1 <= k  <= n) 对于每一个图，有多少个图和它一样

思路：图Hash，枚举起点，再枚举长度，这样每次加边都是一条，时间复杂度O(n ^ 2)

#include <bits/stdc++.h>
using namespace std; 

#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
#define ll long long 
#define N 2003

typedef pair <int, int> pii;

struct simplehash
{
    int len;
    ll base, mod;
    vector <ll> P, H;

    inline simplehash() {}
    inline simplehash(const int *ar, int n, ll b, ll m)
    {
        len = n; base = b, mod = m;
        P.resize(len + 3, 1); H.resize(len + 3, 0);
        for (int i = 1; i <= len; ++i) P[i] = (P[i - 1] * base) % mod;
        for (int i = 1; i <= len; ++i) H[i] = (H[i - 1] + P[ar[i]]) % mod;
    }

    inline ll range_hash(int l, int r)
    {
        ll hashval = (H[r] - H[l - 1]) % mod;
        return (hashval < 0 ? hashval + mod : hashval);
    }
};

struct arrayhash
{
    simplehash sh1, sh2;
    inline arrayhash() {}
    inline arrayhash(const int *ar, int n)
    {
        sh1 = simplehash(ar, n, 1949313259, 2091573227);
        sh2 = simplehash(ar, n, 1997293877, 2117566807);
    }
    inline ll range_hash(int l, int r)
    {
        return (sh1.range_hash(l, r) << 32) ^ (sh2.range_hash(l, r));
    }
};

int t, n, pos;
map <pii, int> mp;
unordered_map <ll, int> mp2;
int arr[N];

inline void Init()
{
    mp.clear(); pos = 0;
    mp2.clear();
}

struct Edge
{
    int u, v, id;
    inline void scan()
    {
        scanf("%d%d", &u, &v);
        if (u > v) swap(u, v);
        if (!mp.count(pii(u, v)))
            mp[pii(u, v)] = mp.size() + 1;
        id = mp[pii(u, v)];
    }
}edge[N];

inline void Run() 
{ 
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n); Init();
        for (int i = 1; i <= n; ++i)
        {
            edge[i].scan(); 
            arr[i] = edge[i].id; 
        }
        ll ans = 0;
        arrayhash x = arrayhash(arr, n);
        for (int i = 1; i <= n; ++i)
        {
            for (int j = i; j <= n; ++j) 
            {
                ll Hash = x.range_hash(i, j);
                ans += mp2[Hash]++;
            }
        }
        printf("%lld
", ans);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif

    Run();
    
    return 0;
}

C：Help Shahhoud

题意：给出A串和B串，每次可以翻转以A串中心点为轴，翻转长度为x，求长度最少使得串A变成串B，如果不行输出-1

思路：很显然要从外往里翻，如果某一段翻转性质相同，那么可以一并翻转，要特别考虑一下四个字符都相同，那么既可以翻转既可以不翻转

#include<bits/stdc++.h>

using namespace std;

#define N 100010

int t;
char A[N];
char B[N];

int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s", A + 1);
        scanf("%s", B + 1);
        int len = strlen(A + 1);
        int ans = 0;
        int flag = 0;
        for(int i = 1; i <= len / 2; ++i)
        {
            int l = i, r = len - i + 1;
            if(A[l] == A[r] && A[l] == B[r] && B[l] == B[r]) continue;
            else if(A[l] == B[r] && A[r] == B[l])
            {
                if(flag == 0)
                {
                    ++ans;
                    flag = !flag;
                }
            }
            else if(A[l] == B[l] && A[r] == B[r])
            {
                if(flag == 1)
                {
                    ++ans;
                    flag = !flag;
                }
            }
            else
            {
                ans = -1;
                break;
            }
        }
        if(A[(len + 1) / 2] != B[(len + 1) / 2]) ans = -1;
        printf("%d
",ans);
    }
    return 0;
}

D：Simplified 2048

留坑。

E：Floods

题意：给出n个点形成山地（折线图），在下过一段时间的雨后留下的雨量。

思路：显然只有凹下去的点才能做出贡献。所以可以分为以下几种情况。一种是图中一部分，一种是图中二部分。对于一部分即求一个梯形面积，对于第二部分即求一个三角形的相似三角形的面积，累加一下即可。

#include<bits/stdc++.h>

using namespace std;

#define N 100010

struct node{
    int x,y;
    inline node(){}
    inline node(int x,int y) :x(x),y(y){}
}a[N];

int L[N];
int R[N];
int n;

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d %d",&a[i].x,&a[i].y);
        }    
        int Max = 0;
        for(int i = 1; i <= n; ++i)
        {
            Max = max(Max,a[i].y);
            L[i] = Max;
        }
        Max = 0;
        for(int i = n; i >= 1; --i)
        {
            Max = max(Max, a[i].y);
            R[i] = Max;
        }
        double ans = 0;
        for(int i = 1; i < n; ++i)
        {
            int top, Max, Min;
            if(a[i].y < a[i + 1].y)
            {
                top = min(L[i], R[i]);
                Max = a[i + 1].y;
                Min = a[i].y;
            }
            else
            {
                top = min(L[i + 1], R[i + 1]);
                Max = a[i].y;
                Min = a[i + 1].y;
            }
            if(top >= Max)
            {
                ans += (double)(a[i + 1].x - a[i].x) * (top - a[i].y + top - a[i + 1].y) * 0.5;
            }
            else if(top > Min)
            {
                ans += (double)(a[i + 1].x - a[i].x) * (top - Min) * (top - Min) / (Max - Min) * 0.5;
            }
        }
        printf("%.8f
",ans);
    }
    return 0;
}

F：Random Sort

题意：给出n个数，对标号全排列，看有多少种排列里面的数是排好的

思路：如果有相同的数，那么对于这个数它的贡献是fac[x] (fac是阶乘，x是个数)

#include<bits/stdc++.h>

using namespace std;

const int MOD = 7901;

#define N 1010

int inv[N];
int n;
int a[N];

int main()
{
    inv[0] = 1;
    for(int i = 1; i < N; ++i)
    {
        inv[i] = inv[i - 1] * i % MOD;
    }
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int ans = 1;
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d",&a[i]);
        }
        sort(a + 1, a + 1 + n);
        int cnt = 1;
        for(int i = 2;i <= n; ++i)
        {
            if(a[i - 1] == a[i])
            {
                cnt++;
            }
            else
            {
                ans = ans * inv[cnt] % MOD;
                cnt = 1;
            }
        }
        ans = ans * inv[cnt] % MOD;
        printf("%d
",ans);
    }
    return 0;
}

G：Weird Requirements

题意：给出n个数，修改最少的数字，使得gcd=x，lcm=y。

思路：显然，一个数的因数不包括gcd和lcm的因数是一定要修改的。统计这些数字的个数。当剩下的数字的因数都满足gcd与lcm的因数的时候，显然最多修改两个数字。那么当必定修改的数的个数大于等于2的时候输出这个数字即可。对于剩下的数字，求出他们的gcd与lcm。那么y/gcd为需要增加的因数，lcm/x为需要减少的因数，但是当增加的因数和减少的因数的gcd！=1时需要修改两个数字。例如gcd=6，lcm=24，五个数分别为12 12 12 12 14

#include <bits/stdc++.h>

using namespace std;

#define N 100010

typedef long long ll;

int t, n;
ll arr[N];
ll x, y;

inline ll GCD(ll a, ll b)
{
    return b == 0 ? a : GCD(b, a % b);
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        scanf("%lld%lld", &x, &y);
        for (int i = 1; i <= n; ++i) scanf("%lld", arr + i); 
        if (y % x)
        {
            puts("-1");
            continue;
        }
        if(n == 1 && x != y)
        {
            puts("-1");
            continue;
        }
        int ans = 0; 
        ll gcd = y, lcm = x;  
        for (int i = 1; i <= n; ++i)
        {
            if(arr[i] % x || y % arr[i]) ++ans;
            else
            {
                gcd = GCD(gcd, arr[i]);
                lcm = lcm * arr[i] / GCD(lcm, arr[i]);
            }
        }
        if (ans >= 2) 
            printf("%d
", ans);
        else if(ans == 1)
        {
            if(gcd != x && lcm != y && GCD(y / gcd, lcm / x) != 1)
            {
                puts("2");
            }
            else
            {
                puts("1");
            }
        }
        else 
        {
            if(x == gcd && y == lcm)
            {
                puts("0");
            }
            else if(x != gcd && y != lcm && GCD(x / gcd, lcm / y) != 1)
            {
                puts("2");
            }
            else 
            {
                puts("1");
            }
        }
    }
    return 0;
}

H：Shahhoud the Chief Judge

题意：一棵树，每个点有权值，sum = sgm(每个点的权值 * 路径经过它的次数)

思路：设cnt[i] 表示经过第i个点的路径数，如果存在gcd(cnt[i], cnt[j]) == 1 ，那么通过i, j 这两个数，就可以构造出所有的整数

裴蜀定理: ax + by = cgcd(a,b)；  c为任意整数，当gcd(a, b)==1 时   cgcd(a, b) 为任意整数

在这棵二叉树中，必然存在这两个数

考虑深度最深的叶子结点cnt[x] = 2 * n - 1, 那么它的父亲结点的cnt[fa] = 6 * n - 11

gcd(2n - 1, 6n - 11) = gcd(2n - 1, -8) = 1 因为2n - 1 是奇数

#include <bits/stdc++.h>
using namespace std; 

#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
#define ll long long 
#define N 100010

inline ll GCD(ll a, ll b)
{
    return (ll)b ? GCD(b, a % b) : a;
}

struct Edge
{
    int to, nx;
    inline Edge() {}
    inline Edge(int to, int nx) : to(to), nx(nx) {}
}edge[N << 1];

int head[N], pos;
int t, n;
ll arr[N];
ll cnt[N]; 
ll num[N];
ll son[N][2];
int fa[N];
ll sum;

inline void Init()
{
    memset(head, -1, sizeof head);
    pos = 0; fa[1] = 1; sum = 0;
}

inline void addedge(int u, int v)
{
    edge[++pos] = Edge(v, head[u]); head[u] = pos;
    edge[++pos] = Edge(u, head[v]); head[v] = pos;
}

inline void DFS(int u)
{
    cnt[u] = 1;
    son[u][0] = son[u][1] = 0;
    for (int it = head[u]; ~it; it = edge[it].nx)
    {
        int v = edge[it].to;
        if (v == fa[u]) continue;
        fa[v] = u; DFS(v);
        cnt[u] += cnt[v];
        if (son[u][0])
            son[u][1] = cnt[v];
        else
            son[u][0] = cnt[v];
    } 
    num[u] = (ll)(2 * n - 1) + (ll)(n - cnt[u]) * (cnt[u] - 1) * 2 + (ll)(son[u][0] * son[u][1] * 2);
    sum += arr[u] * num[u]; 
}

inline void work()
{
    if (sum == 0)
    {
        puts("0"); 
        return;
    }
    int id = 1; 
    for (int i = 1; i <= n; ++i)
    {
        if (sum % num[i] == 0) 
        {
            printf("1
%d
", i);
            return;
        }
        if (GCD(num[i], num[fa[i]]) == 1)
            id = i;
    }
    printf("2
%d %d
", fa[id], id);
}

inline void Run() 
{ 
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        Init(); 
        for (int i = 1; i <= n; ++i) scanf("%lld", arr + i);
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            addedge(u, v);
        }
        DFS(1);
        work();
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif

    Run();
    
    return 0;
}

I：lldar Yalalov

题意：n堆石子，每一堆有ai个，两个人轮流取，取的操作只有两种

1° 从一堆中取一个

2°每一堆取一个，当且仅当所有堆都至少有一个才能有这个操作

思路：

如果是奇数堆，那么取一个和从所有堆中取一个的操作实际上是一样的，因为取的都是奇数个，不会影响胜负  直接% 2 判断

如果是偶数堆，并且总个数是奇数，那么先手是必胜的，因为如果最小堆里面的石子个数是奇数个，那么只要一直取这里的，如果他取一排，跟着他取

如果总个数是偶数，并且最小堆里面石子个数是偶数，那么是胜利的，因为先手改变命运的次数多一次

#include <bits/stdc++.h>

using namespace std;
#define INF 0x3f3f3f3f
#define N 110

int t;
int n, sum, Min;
int arr[N];

inline bool work()
{
    if (n & 1) 
    {
        return (sum & 1);
    }
    if (sum & 1) return true;
    else
    {
        return (Min & 1);
    }    
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        sum = 0, Min = INF;
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i), sum += arr[i], Min = min(Min, arr[i]);
        puts(work() ? "Yalalov" : "Shin");
    }
    return 0;
}

J：Saeed and Folan

水。

#include <bits/stdc++.h>

using namespace std;

int t, k;
int L[2], R[2], p[2], D[2];

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        for (int i = 0; i < 2; ++i)
            scanf("%d%d%d%d", &L[i], &R[i], &p[i], &D[i]);
        scanf("%d", &k);
        for (int i = 0; i < 2; ++i) if (D[i] == 0)
            D[i] = -1;
        int ans = 0;
        if (p[0] == p[1]) ++ans;
        if (p[0] == L[0]) D[0] = 1;
        if (p[0] == R[0]) D[0] = -1;
        if (p[1] == L[1]) D[1] = 1;
        if (p[1] == R[1]) D[1] = -1;
        for (int i = 1; i <= k; ++i)
        {
            for (int j = 0; j < 2; ++j) 
                p[j] += D[j];
            if (p[0] == p[1]) ++ans;
            for (int j = 0; j < 2; ++j)
            {
                if (p[j] == R[j]) D[j] = -1;
                if (p[j] == L[j]) D[j] = 1; 
            }
        }
        printf("%d
", ans);
    }    
    return 0;
}

K：Another Shortest Path Problem

题意：n个点，n条边，没有重边和自环，每次询问给出u, v 询问u -> v的最短路径

思路：这个图是一棵树加一个环，那么我们找出这个环中边权最大的边

那么最短路只有两种状况，经过这条边和不经过这条边 然后找LCA处理一下

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int DEG = 20;
const int maxn = 1e5 + 10;

struct node{
    int u,v;
    ll w;
    inline node(){}
    inline node(int u,int v,ll w): u(u), v(v), w(w){}    
    inline bool operator < (const node &b)
    {
        return w < b.w;
    }
}G[maxn];

struct Edge{
    int to,nxt;
    ll w;
    inline Edge(){}
    inline Edge(int to,int nxt, ll w):to(to), nxt(nxt), w(w) {}
}edge[maxn << 1];

int n,q;
int head[maxn], tot;
int father[maxn];
ll dis[maxn];

inline int find(int x)
{
    return father[x] == x ? father[x] : father[x] = find(father[x]); 
}

inline void mix(int x,int y)
{
    x = find(x);
    y = find(y);
    if(x != y)
    {
        father[x] = y;
    }
}

inline bool same(int x,int y)
{
    return find(x) == find(y);
}

inline void addedge(int u,int v,ll w)
{
    edge[tot] = Edge(v, head[u],w);
    head[u] = tot++;
}

inline void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
    for(int i = 1; i <= n; ++i) father[i] = i;
}

int fa[maxn][DEG];
int deg[maxn];

inline void BFS(int root)
{
    queue<int>q;
    deg[root] = 0;
    fa[root][0] = root;
    q.push(root);
    while(!q.empty())
    {
        int tmp = q.front();
        q.pop();
        for(int i = 1;i < DEG; ++i)
        {
            fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
        }
        for(int i = head[tmp]; ~i; i = edge[i].nxt)
        {
            int v = edge[i].to;
            if(v == fa[tmp][0]) continue;
            dis[v] = dis[tmp] + edge[i].w;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            q.push(v);    
        }
    }
}

inline int LCA(int u, int v)
{
    if(deg[u] > deg[v]) swap(u,v);
    int hu = deg[u], hv = deg[v];
    int tu = u,tv = v;
    for(int det = hv - hu, i = 0;det; det >>= 1, ++i)
    {
        if(det & 1)
        {
            tv = fa[tv][i];
        }
    }
    if(tu == tv) return tu;
    for(int i = DEG - 1; i >= 0; --i)
    {
        if(fa[tu][i] == fa[tv][i]) continue;
        tu = fa[tu][i];
        tv = fa[tv][i];
    }
    return fa[tu][0];
}

inline ll query(int u,int v)
{
    int root = LCA(u,v);
    return dis[u] + dis[v] - 2 * dis[root];
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&q);
        init();
        int a,b;
        ll cost;
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d %d %lld", &G[i].u, &G[i].v, &G[i].w);
        }
        sort(G + 1, G + 1 + n);
        for(int i = 1; i <= n; ++i)
        {
            int u = G[i].u;
            int v = G[i].v;
            ll w = G[i].w;
            if(same(u, v))
            {
                a = u;
                b = v;
                cost = w;
            }
            else
            {
                mix(u,v);
                addedge(u,v,w);
                addedge(v,u,w);
            }
        }
        dis[1] = 0;
        BFS(1);
        while(q--)
        {
            int u,v;
            scanf("%d %d",&u,&v);
            ll ans = query(u, v);
            ans = min(ans, query(u, a) + query(v, b) + cost);
            ans = min(ans, query(v, a) + query(u, b) + cost);
            printf("%lld
",ans);
        }
    }
    return 0;
}

L：V--o$\_$o--V

Upsolved.

题意：

$对每一个点i求下标小于i的所有点的LCA的点权和$

思路：

考虑一个点对多个点求分别的$LCA$ 可以树剖对那些点从当前点到根打标记，那么目标点对他们求$LCA就是从当前点走到根看一下打的标记最多的是哪个$

那么此处也可以同样处理，我们需要设计一种标记，使得从该点到根的路径上所有标记点加起来恰好是当前点权值

我们可以这么处理 在这里约定$w[u] 表示点u的点权，x[u] 表示树上的标记, fa[u] 表示点u的父亲$  

那么 $x[u] = w[fa[u]] - w[i]$

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 200010
int t, n, w[N];
vector <int> G[N];

ll dis[N];
int deep[N], fa[N], sze[N], son[N], top[N], p[N], fp[N], cnt;
void DFS(int u)
{
    sze[u] = 1; 
    for (auto v : G[u]) 
    {
        deep[v] = deep[u] + 1;
        dis[v] = w[v] - w[u];
        DFS(v); sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}

void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (!son[u]) return;
    getpos(son[u], sp);
    for (auto v : G[u]) if (v != son[u])
        getpos(v, v);
}

namespace SEG
{
    ll sum[N << 2], add[N << 2], lazy[N << 2];
    void build(int id, int l, int r)
    {
        sum[id] = lazy[id] = 0; 
        if (l == 1) sum[id] = dis[1];
        if (l == r)
        {
            add[id] = dis[fp[l]];
            return;
        }
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
        add[id] = add[id << 1] + add[id << 1 | 1];
    }
    void work(int id, int l, int r, int ql, int qr, ll &res) 
    {
        if (l >= ql && r <= qr) 
        {
            res += sum[id];
            sum[id] += add[id];
            ++lazy[id];
            return;        
        }
        if (lazy[id])
        {
            lazy[id << 1] += lazy[id];
            sum[id << 1] += lazy[id] * add[id << 1];
            lazy[id << 1 | 1] += lazy[id];
            sum[id << 1 | 1] += lazy[id] * add[id << 1 | 1];
            lazy[id] = 0;
        }
        int mid = (l + r) >> 1;
        if (ql <= mid) work(id << 1, l, mid, ql, qr, res);
        if (qr > mid) work(id << 1 | 1, mid + 1, r, ql, qr, res);
        sum[id] = sum[id << 1] + sum[id << 1 | 1];
    }
}

ll work(int u, int v)
{
    ll res = 0;
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        SEG::work(1, 1, n, p[top[u]], p[u], res);
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    SEG::work(1, 1, n, p[u], p[v], res); 
    return res;
}

void init()
{
    for (int i = 1; i <= n; ++i) G[i].clear(), son[i] = 0;
    cnt = 0;
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n); init();
        for (int i = 1; i <= n; ++i) scanf("%d", w + i); 
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", fa + i);
            G[fa[i]].push_back(i);
        } dis[1] = w[1]; DFS(1); getpos(1, 1);        
        SEG::build(1, 1, n); 
        for (int i = 2; i <= n; ++i) printf("%lld%c", work(1, i), " 
"[i == n]);
    }
    return 0;
}