ZOJ Monthly, June 2018 Solution

A - Peer Review

Water.

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

int t, n;

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) printf("0%c", " 
"[i == n]);
    }
    return 0;
}

B - Boring Game

Unsolved. 

C - Enigma Machine

Unsolved.

D - Number Theory

Unsolved.

E - Chasing

Solved.

题意：两个人在一个二维平面上，刚开始两个人在第二象限或者第三象限，A跑到Y轴B就不能追了，B的速度是A的K倍，求B能否追到B

思路：k < 0 那么必然不行

k == 0 判断是不是在同一高度，如果是判断起始位置

k > 0  假设y轴上存在某个点 使得A B 能够在该点相遇，列方程求解

#include<bits/stdc++.h>

using namespace std;

double xa, xb, ya, yb, k;

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%lf %lf %lf %lf %lf", &xa, &ya, &xb, &yb, &k);
        if(k < 1.0)
        {
            puts("N");
        }
        else if(k == 1.0)
        {
            if(ya != yb) puts("N");
            else if(xb < xa) puts("N");
            else puts("Y");
        }
        else
        {
            double a = k * k - 1.0;
            double b = -2.0 * k * k * ya + 2.0 * yb;
            double c = k * k * xa * xa - xb * xb + k * k * ya * ya - yb * yb;
            double d = b * b - 4.0 * a * c;
            if(d >= 0) puts("N");
            else puts("Y");
        }
    }    
    return 0;
}

F - Carrot Gathering

Unsolved.

G - Virtual Singers

Upsolved.

题意：

H - How Many Palindromes

Unsolved.

 题意：

有$n个A数和m个B数 m <= n，对每个B数都匹配一个A数，使得sum_{i = 1}^{i = m} |B[i] - A[i]| 最小$

思路：

考虑费用流的思想，维护三个堆

将$A、B 数放在一起排序，然后从左往右枚举$

$如果当前数是A$

　　如果左边有未匹配的$B_1数，那么与之匹配即可，此操作不用考虑反悔操作$

　　$因为假如有另一个B_2，使得B_2 与 这个A匹配更优$

　　那么后面必然要有另一个$A_2 来匹配这个B_1 $

　　$贡献是 A_2 - B_1 + B_2 - A_1 这个式子显然小于 A_2 - B_2 + A_1 - B_1$

　　因为这四个数字存在大小关系

　　$A_2 - B_1 大于 A_2 - B_2 + A_1 - B_1$

　　如果左边没有未匹配的$B_1数，那么考虑B的反悔操作是否更优$

　　$更优的话就反悔并且将代价取反并算上A往右匹配的贡献放入堆Q_A中， 相当于反悔操作$

$如果当前数是B$

　　$如果左边有未匹配的A数，那么与之匹配，并且将代价取反并且算上B往右匹配的贡献放入堆Q_C中$

　　否则放入堆$Q_B$中表示还未匹配

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

#define ll long long
#define N 100010
int t, n, m; ll x;
struct node 
{
    ll v; int Type;
    node () {}
    node (ll v, int Type) : v(v), Type(Type) {}
    bool operator < (const node &r) const { return v < r.v; }   
}arr[N << 1];
priority_queue <ll, vector <ll> , greater <ll> > A, B, C;  

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        while (!A.empty()) A.pop();
        while (!B.empty()) B.pop();
        while (!C.empty()) C.pop();
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; ++i) 
        {
            scanf("%lld", &x);
            arr[i] = node(x, 0);
        }
        for (int i = 1; i <= m; ++i)
        {
            scanf("%lld", &x);
            arr[n + i] = node(x, 1);
        }
        sort(arr + 1, arr + 1 + n + m);
        ll res = 0;
        for (int i = 1; i <= n + m; ++i)
        {
            if (arr[i].Type == 1)
            {
                if (!A.empty())
                {
                    x = A.top(); A.pop();
                    res += arr[i].v + x;
                    C.push(-x - 2 * arr[i].v);
                }
                else 
                    B.push(-arr[i].v); 
            }
            else
            {
                if (!B.empty())
                {
                    x = B.top(); B.pop();
                    res += arr[i].v + x;
                }
                else if (!C.empty()) 
                {
                    x = C.top(); 
                    if (arr[i].v + x < 0)
                    {
                        C.pop();
                        res += arr[i].v + x;
                        A.push(-x - 2 * arr[i].v);
                    }
                    else 
                        A.push(-arr[i].v);
                }
                else
                    A.push(-arr[i].v); 
            }
        }
        printf("%lld
", res);
    }
    return 0;
}

I - District Division

Solved.

题意：给出一棵树，求能不能分成$frac{n}{k}$ 个连通块，使得每块个数为k

思路：如果存在合法分法，那么必然存在某个子树大小为k，DFS下去，再回溯上来判断即可，遇到大小为k的子树就分块

#include<bits/stdc++.h>

using namespace std;

const int maxn = 1e5 + 10;

int n, k;

int val[maxn];
int fa[maxn];
int vis[maxn];
int cnt;
vector<int>root;
vector<int>G[maxn];

void Init()
{
    cnt = 0;
    root.clear();
    for(int i = 1; i <= n; ++i)
    {
        val[i] = vis[i] = 0;
        fa[i] = i;
        G[i].clear();
    }    
}

void DFS(int u, int pre)
{
    val[u] = 1;
    fa[u] = pre;
    for(int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if(v == pre) continue;
        DFS(v, u);
        val[u] += val[v];
    }
    if(val[u] == k)
    {
        cnt++;
        val[u] = 0;
        root.push_back(u);
    }
}

void DFS2(int u, int pre)
{
    if(vis[u]) return ;
    vis[u] = 1;
    printf("%d%c", u, " 
"[cnt == k]);
    cnt++;
    for(int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if(v == pre) continue;
        DFS2(v, u);
    }
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &n, &k);
        Init();
        for(int i = 1; i < n; ++i)
        {
            int u, v;
            scanf("%d %d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1, -1);
        if(cnt != n / k)
        {
            puts("NO");
            continue;
        }
        puts("YES");
        for(int i = 0, len = root.size(); i < len; ++i)
        {
            cnt = 1;
            DFS2(root[i], fa[root[i]]);
        }
    }    
    return 0;
}

J - Good Permutation

Solved.

题意：每次能够交换相邻两个数，求最少交换次数使得满足题目给出的序列条件

思路：通过枚举每次在第一位的数，从而递推下一种状态，比如12345推出51234即加上5移到第一位的步数再减去5带来的贡献

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn = 1e5 + 10;

int n;
int arr[maxn];
int pos[maxn];
int a[maxn];

int lowbit(int p)
{
    return p & (-p);
}

void update(int p)
{
    while(p <= n)
    {
        a[p]++;
        p += lowbit(p);
    }
}

int query(int p)
{
    int res = 0;
    while(p)
    {
        res += a[p];
        p -= lowbit(p);
    }
    return res;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        ll ans = 0;
        for(int i = 1; i <= n; ++i) a[i] = 0;
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d", arr + i);
            pos[arr[i]] = i;
        }
        for(int i = n; i >= 1; --i)
        {
            ans += query(arr[i] - 1);
            update(arr[i]);
        }
        ll tmp = ans;
        for(int i = 1; i <= n; ++i)
        {
            tmp = tmp + n - pos[i] - (pos[i] - 1);
            ans = min(ans, tmp);
        }
        printf("%lld
", ans);
    }
    return 0;
}