2017-2018 ACM-ICPC German Collegiate Programming Contest (GCPC 2017) Solution

A. Drawing Borders

Unsolved.

B. Buildings

Unsolved.

C. Joyride

Upsolved.

题意：

在游乐园中，有n个游玩设施，有些设施之间有道路，给出每个设施需要花费的时间和价格，以及经过每条道路的时间，求从设施1出发恰好回到设施1恰好花费时间x的最小花费。

思路：

$dist[i][j] 表示 第i个时刻 到第j个点的最小花费  从<t[1], 1> -> <x, 1>$

跑最短路即可

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

#define N 3010
#define ll long long
#define INF 0x3f3f3f3f3f3f3f3f
int X, n, m, T, t[N], p[N]; 
vector <int> G[N];

struct node
{
    int x, to; ll w;
    node () {}
    node (int x, int to, ll w) : x(x), to(to), w(w) {}
    bool operator < (const node &r) const { return w > r.w; }
};

bool used[N][N]; 
ll dist[N][N];
void Dijkstra()
{
    for (int i = 1; i <= X; ++i) for (int j = 1; j <= n; ++j) dist[i][j] = INF, used[i][j] = 0;
    priority_queue <node> q; q.emplace(t[1], 1, 0); dist[t[1]][1] = p[1]; 
    while (!q.empty())
    {
        int x = q.top().x, u = q.top().to; q.pop();
        if (x > X) continue;
        if (used[x][u]) continue;
        used[x][u] = 1;
        if (!used[x + t[u]][u] && dist[x + t[u]][u] > dist[x][u] + p[u]) 
        {
            dist[x + t[u]][u] = dist[x][u] + p[u];
            q.emplace(x + t[u], u, dist[x + t[u]][u]);
        }
        for (auto v : G[u]) if (!used[x + t[v] + T][v] && dist[x + t[v] + T][v] > dist[x][u] + p[v])
        {
            dist[x + t[v] + T][v] = dist[x][u] + p[v];
            q.emplace(x + t[v] + T, v, dist[x + t[v] + T][v]);
        }
    }    
}

int main()
{
    while (scanf("%d", &X) != EOF)
    {
        scanf("%d%d%d", &n, &m, &T);
        for (int i = 1, u, v; i <= m; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        for (int i = 1; i <= n; ++i) scanf("%d%d", t + i, p + i);
        Dijkstra();
        if (dist[X][1] == INF) puts("It is a trap.");
        else printf("%lld
", dist[X][1]);
    }
    return 0; 
}

D. Pants On Fire

Solved.

题意：

给出一些关系，再给出一些关系的询问，对于询问给出三种结果。

思路：

Floyd求闭包，但是我还是想知道为什么拓扑排序不行，难道是题意读错，它不一定是个DAG?

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

#define N 410
int n, m; 
map <string, int> mp; int cnt; 
char a[N], b[N];
int G[N][N]; 

int getid(char *s)
{
    if (mp.find(s) == mp.end()) mp[s] = ++cnt;
    return mp[s];
}

void Floyd()
{
    for (int k = 1; k <= cnt; ++k)
    {
        for (int i = 1; i <= cnt; ++i)
        {
            for (int j = 1; j <= cnt; ++j)
            {
                if (G[i][k] & G[k][j])
                    G[i][j] = 1;
            }
        }
    }
}

void init()
{
    memset(G, 0, sizeof G); 
    mp.clear(); cnt = 0; 
}

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        init();
        for (int i = 1, u, v; i <= n; ++i)
        {
            scanf("%s are worse than %s", a, b);
            u = getid(a), v = getid(b);
            G[u][v] = 1;
        }
        Floyd(); 
        //for (auto it : mp) cout << it.first << " " << rt[it.second] << " " << deep[it.second] << endl;
        for (int i = 1, u, v; i <= m; ++i)
        {
            scanf("%s are worse than %s", a, b);
            u = getid(a), v = getid(b);
            if (G[u][v] == 1) puts("Fact");
            else if (G[v][u] == 1) puts("Alternative Fact");
            else puts("Pants on Fire");
        }
    }
    return 0;
}

E. Perpetuum Mobile

Upsolved.

题意：

有n个转换器，m个转换关系，转换关系是有向边

求从哪个点出发回到起点后经过的转换大于原来的值

思路：

枚举起点跑最长路，乘法可以取个$log$, 当然也可以再取个负跑最短路也可以

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

#define N 10010
#define INF 0x3f3f3f3f
#define pid pair <int, double>
int n, m;
vector <pid> G[N];

struct node
{
    int to; double w;
    node () {}
    node (int to, double w) : to(to), w(w) {}
    bool operator < (const node &r) const { return w < r.w; }
};

double dist[N]; bool used[N];
bool Dijkstra(int st)
{
    for (int i = 1; i <= n; ++i) dist[i] = 0.0, used[i] = false;
    priority_queue <node> q; q.emplace(st, 0);  
    while (!q.empty())
    {
        int u = q.top().to; q.pop(); 
        if (used[u] && u == st && dist[u] > 0) return false;  
        if (used[u]) continue;
        used[u] = 1;
        for (auto it : G[u]) if (dist[it.first] < dist[u] + log(it.second)) 
        {
            dist[it.first] = dist[u] + log(it.second);
            q.emplace(it.first, dist[it.first]);
        }
    }    
    return true;
}

bool solve()
{
    for (int i = 1; i <= n; ++i) if (Dijkstra(i) == false)
        return false; 
    return true;
}

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= n; ++i) G[i].clear();
        double w;
        for (int i = 1, u, v; i <= m; ++i)
        {
            scanf("%d%d%lf", &u, &v, &w);
            G[u].emplace_back(v, w);
        }
        if (solve() == false) printf("in");
        puts("admissible");
    }
    return 0;
}

F. Plug It In

Unsolved.

题意：

给出一个匹配关系，可以设置一个人和三个人匹配，求最大匹配数。

思路：

先求最大匹配，再枚举每个插座，找增广路，枚举点的时候都要复制原图备份一下

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

#define N 1510
int n, m, k;
vector <int> G[N];
int linker[N], vis[N], tmp[N];

bool DFS(int u)
{
    for (auto v : G[u]) if (!vis[v])
    {
        vis[v] = 1; 
        if (linker[v] == -1 || DFS(linker[v]))
        {
            linker[v] = u;
            return true;
        }
    }
    return false;
}

int main()
{
    while (scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        for (int i = 1; i <= n; ++i) G[i].clear();
        for (int i = 1, u, v; i <= k; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
        }
        memset(linker, -1, sizeof linker);
        int res = 0, ans = 0;
        for (int i = 1; i <= n; ++i)
        {
            memset(vis, 0, sizeof vis);
            if (DFS(i)) ++res;
        }
        memcpy(tmp, linker, sizeof linker);
        for (int i = 1; i <= n; ++i)
        {
            int cnt = 0;
            for (int j = 1; j <= 2; ++j)
            {
                memset(vis, 0, sizeof vis);
                if (DFS(i)) ++cnt;    
            }
            ans = max(ans, cnt);
            memcpy(linker, tmp, sizeof tmp);
        }
        printf("%d
", res + ans);
    }
    return 0;
}

G. Water Testing

Upsolved.

题意：求一个多边形内部整点个数。

思路：

皮克定理：$S = a + frac{b}{2} - 1   S表示多边形面积，frac{b}{2} 表示 多边形边上的整点数   a 表示多边形内部整点数$

因为点是按顺序给出，有求面积公式$S = frac{1}{2} sum_{i = 0}^{i = n}|vec{P_i} x vec{P_i - 1}|$

再考虑 线段上的整点个数为

$令 a = abs(stx - edx), b = abs(sty - edy)，整点个数为gcd(a, b) + 1$

考虑证明：

根据直线两点式有：

$y - y_1 = frac{y_2 - y_1}{x_2 - x_1} cdot (x - x _1)$

移项得

$y = frac{y_2 - y_1}{x_2 - x_1} cdot (x - x_1) + y_1$

即考虑 有多少个$x使得 (x - x_1) equiv 0 pmod {x_2 - x_1}$

由于 $x 在 [x1, x2] 范围内 那么 (x - x_1) 的范围即 [0, x2 - x1]$

$考虑 frac{y_2 - y_1}{x_2 - x_1} 可以跟他们的gcd约分$

$frac{x_2 - x_1}{ frac {x_2 - x_1}{gcd((y_2 - y_1), (x_2 - x_1))}} = gcd((y_2 - y_1), (x_2 - x_1))$

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

#define N 100010
#define ll long long
int n; 
ll x[N], y[N];

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

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i)
            scanf("%lld%lld", x + i, y + i);
        x[0] = x[n]; y[0] = y[n];
        ll s = 0, b = 0;
        for (int i = 1; i <= n; ++i)
        {
            s += x[i - 1] * y[i] - x[i] * y[i - 1];
            ll A = abs(x[i] - x[i - 1]);
            ll B = abs(y[i] - y[i - 1]);
            b += gcd(A, B);
        }
        s = abs(s); 
        printf("%lld
", (s - b + 2) >> 1);  
    }
    return 0;
}

H. Ratatoskr

Unsolved.

I. Uberwatch

Water.

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

#define N 300010
int n, m, x[N], Max[15];

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        memset(Max, 0, sizeof Max);
        for (int i = 1; i <= n; ++i) scanf("%d", x + i);
        for (int i = m + 1, res; i <= n; ++i)
        {
            res = x[i] + Max[m];
            for (int j = m; j >= 1; --j) Max[j] = max(Max[j], Max[j - 1]);
            Max[1] = max(Max[1], res);
        }
        printf("%d
", *max_element(Max + 1, Max + 1 + m));
    }
    return 0;
}

J. Word Clock

Unsolved.

K. You Are Fired

Water.

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

#define N 10010
int n, k, d;
struct node
{
    char s[10]; int c;
    void scan()
    {
        scanf("%s%d", s, &c);
    }
    bool operator < (const node &r) const {return c > r.c;}
}emp[N];

int main()
{
    while (scanf("%d%d%d", &n, &d, &k) != EOF)
    {
        for (int i = 1; i <= n; ++i) emp[i].scan();
        sort(emp + 1, emp + 1 + n);
        int tot = 0;
        for (int i = 1; i <= k; ++i) tot += emp[i].c;
        if (tot < d) puts("impossible");
        else
        {
            printf("%d
", k);
            for (int i = 1; i <= k; ++i) printf("%s, YOU ARE FIRED!
", emp[i].s);
        }
    }
    return 0;
}