2017 Benelux Algorithm Programming Contest (BAPC 17) Solution

A - Amsterdam Distance

题意：极坐标系，给出两个点，求最短距离

思路：只有两种方式，取min  第一种，先走到0点，再走到终点 第二种，走到同一半径，再走过去

#include <bits/stdc++.h>

using namespace std;
#define INF 0x3f3f3f3f

const double PI = acos(-1.0);

double n, m, r;
double n1, m1, n2, m2;

inline double work1()
{
    double dis1 = r * n1 / n;
    double dis2 = r * n2 / n;
    return dis1 + dis2;
}

inline double work2()
{
    double dis1 = r * (n2 - n1) / n;
    double dis2 = fabs(m1 - m2) * r * n1 * PI/ (n * m);
    return dis1 + dis2;    
}

int main()
{
    while (scanf("%lf%lf%lf", &m, &n, &r) != EOF)
    {
        scanf("%lf%lf%lf%lf", &m1, &n1, &m2, &n2);
        if (n1 > n2) 
        {
            swap(n1, n2);
            swap(m1, m2);
        }
        double ans = INF * 1.0;
        ans = min(ans, work1());
        ans = min(ans, work2());
        printf("%.10f
", ans);
    }
    return 0;
}

B - Bearly Made It

留坑。

C - Collatz Conjecture

题意：给出n个数，求有多少个不同的区间gcd

思路：从头扫过去，每次扩展gcd，如果有重复的直接剪掉

因为假设扫到第i个的时候，有x个gcd  那么到第i个，这x个gcd 如果都被保留下来，那么第i个数一定要是这n个数的倍数，那么显然如果存在这样的数，那么当x > 30 的时候 早就爆 1e18 了 所以复杂度应该在 30 * (n) * log(n)

#include<bits/stdc++.h>

using namespace std;

#define N 500050

typedef long long ll;

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

int n;
ll GCD[N];
ll num;
map<ll, int>mp;

int main()
{
    while(~scanf("%d" ,&n))
    {
        mp.clear();
        int len = 0;
        for(int i = 1; i <= n; ++i)
        {
            scanf("%lld", &num);
            for(int j = 0; j < len; ++j)
            {
                GCD[j] = gcd(GCD[j], num);
            }
            GCD[len++] = num;
            sort(GCD, GCD + len);
            int tmp = 0;
            for(int i = 0; i< len; ++i)
            {
                mp[GCD[i]]++;
                if(i == 0)
                {
                    GCD[tmp++] = GCD[i];
                    continue;
                }
                if(GCD[i] == GCD[i - 1]) continue;
                else GCD[tmp++] = GCD[i];
            }
            len = tmp;
        }
        int ans = mp.size();
        printf("%d
",ans);
    }
    return 0;
}

D - Detour

题意：给出n条路，每次选择的路都不选从这条路到0的最短路径上的路，求最后选的最短路径

思路：先从1反向跑最短路，然后删边，再从0正向跑

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

#define N 100010
#define M 1000010
#define ll long long
#define INFLL 0x3f3f3f3f3f3f3f3f

struct Edge
{
    int to, nx, flag;
    ll w;
    inline Edge() {}
    inline Edge(int to, ll w, int nx, int flag) : to(to), w(w), nx(nx), flag(flag) {}
}edge[M << 1];

int head[N], pos;

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

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

int n, m;

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

ll dist[N];
int pre[N];
bool used[N];

inline void Dijkstra(int st)
{
    for (int i = 0; i < n; ++i) dist[i] = INFLL, used[i] = false, pre[i] = -1;
    dist[st] = 0;
    priority_queue <node> q; q.emplace(st, 0);
    while (!q.empty())
    {
        int u = q.top().to; q.pop();
        used[u] = true;
        for (int it = head[u]; ~it; it = edge[it].nx)
        {
            if (edge[it].flag) continue;
            int v = edge[it].to; ll w = edge[it].w;
            if (!used[v] && dist[u] + w < dist[v])
            {
                dist[v] = dist[u] + w;
                pre[v] = u;
                q.emplace(v, dist[v]);
            }
        }
    }
}


int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        ll w; Init();
        for (int i = 1, u, v; i <= m; ++i)
        {
            scanf("%d%d%lld", &u, &v, &w);
            addedge(u, v, w);
        }
        Dijkstra(1);
        if (dist[0] == INFLL)
        {
            puts("impossible");
            continue;
        }
        for (int i = 0; i < n; ++i)
        {
            for (int it = head[i]; ~it; it = edge[it].nx)
            {
                int v = edge[it].to;
                if (v == pre[i])
                {
                    edge[it].flag = 1;
                    break;
                }
            }
        }
        Dijkstra(0);
        if (dist[1] == INFLL)
        {
            puts("impossible");
            continue;
        }
        vector <int> ans;
        int it = 1;
        while (it != -1)
        {
            ans.push_back(it);
            it = pre[it];
        }    
        reverse(ans.begin(), ans.end());
        int len = ans.size();
        printf("%d ", len);
        for (int i = 0; i < len; ++i) printf("%d%c", ans[i], " 
"[i == len - 1]);

    }
    return 0;
}

E - Easter Eggs

留坑。

F - Falling Apart

水。

#include <bits/stdc++.h>

using namespace std;

int n;
int arr[20];

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i);
        sort(arr + 1, arr + 1 + n);
        int ans[2] = {0, 0};
        int flag = 0;
        for (int i = n; i >= 1; --i)
        {
            ans[flag] += arr[i];
            flag ^= 1;
        }
        printf("%d %d
", max(ans[0], ans[1]), min(ans[0], ans[1]));
    }
    return 0;
}

G - Going Dutch

留坑。

H - Hoarse Horses

留坑。

I - Irrational Division

题意：给出n * m 的矩形，单位边长为1，黑白交替，Alice 只能一列一列取(从左往右)，Bob只能一行一行取(从下往上)，取到的分数为黑块-白块，求Alice 和 Bob 的最大分差，两人操作都最优

思路：可以找一下规律，偶数行 答案是0

奇数行 奇数列 答案是1

奇数行 偶数列  行 < 列 答案是2 否则 答案是0

#include <bits/stdc++.h>

using namespace std;

int n, m;

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        if ((n & 1) == 0)
        {
            puts("0");
            continue;
        }
        if ((m & 1))
        {
            puts("1");
            continue;
        }
        puts(n < m ? "2" : "0");
    }
    return 0;
}

J - Jumping Choreography

留坑。

K - King of the Waves

题意：给出n个人的胜负关系，打擂台赛，求最后0胜利，给出上场顺序

思路：输出DFS序

#include<bits/stdc++.h>

using namespace std;

#define N 1010

int n;
int tot = 0;
int dep[N];
char mp[N][N];
int ans[N];

inline void DFS(int pos, int cnt)
{
    dep[pos] = cnt;
    ans[++tot] = pos;
    for(int i = 1; i <= n; ++i)
    {
        if(mp[pos][i] == '1' && !dep[i])
        {
            DFS(i, cnt + 1);
        }
    }
}

int main()
{
    while(~scanf("%d", &n))
    {
        tot = 0;
        memset(dep, 0 , sizeof dep);
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 1; j <= n; ++j)
            {
                scanf(" %c", &mp[i][j]);
            }
        }
        DFS(1, 1);
        if(tot != n)
        {
            puts("impossible");
        }
        else
        {
            for(int i = n; i >= 1; --i)
            {
                printf("%d%c", ans[i] - 1, " 
"[i == 1]);
            }
        }
    }
    return 0;
}

L - Lemonade Trade

题意：给出n个兑换关系，刚开始有1l pink  最后想换到blue 要依次换，可以选择换和不换

思路：O(n) 扫一下，记录在这之前被兑换的颜色饮料最多能被换到多少 然后取max  注意 不能直接乘法，取log 再取e的幂次

#include<bits/stdc++.h>

using namespace std;

#define N 100010

const int INF = 0x3f3f3f3f;
const double EI = exp(1.0);

int cnt;
map<string, int >mp;
double ans[N];

inline void init()
{
    mp.clear();
    cnt = 1;
    mp["pink"] = cnt++;
    mp["blue"] = cnt++;
    ans[1] = log(1.0);
    ans[2] = -INF * 1.0;
}

int n;
string a, b;
double w;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    while(cin >> n)
    {
        init();
        for(int i = 1; i <= n; ++i)
        {
            cin >> a >> b >> w;
            if(mp[a] == 0)
            {
                mp[a] = cnt++;
                ans[mp[a]] = -INF * 1.0;
            }
            if(mp[b] == 0)
            {
                mp[b] = cnt++;
                ans[mp[b]] = -INF * 1.0;
            }
            int id1 = mp[a], id2 = mp[b];
            ans[id1] = max(ans[id1], ans[id2] + log(w));
        }
        ans[2] = pow(EI, ans[2]);
        ans[2] = min(ans[2], 10.0);
        cout << setiosflags(ios::fixed) << setprecision(10) << ans[2] << endl;
    }
    return 0;
}

M - Manhattan Mornings

题意：给出n个点，起始点和终点，求从起始点到终点的最短路径，最多经过多少点

思路：先排序，固定一个轴，再求最长上升子序列

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

#define N 100010

int n;

struct node
{
    int x, y;
    inline void scan()
    {
        scanf("%d%d", &x, &y);
    }
    inline bool operator < (const node &r) const
    {
        return x < r.x || x == r.x && y < r.y;
    }
}point[N], st, ed;

int arr[N], brr[N];

inline int DP1(int n)
{
    if (n == 0) return 0;
    int i, len, pos;
    brr[1] = arr[1];
    len = 1;
    for (int i = 2; i <= n; ++i)
    {
        if (arr[i] >= brr[len])
        {
            len = len + 1;
            brr[len] = arr[i];
        }
        else
        {
            int pos = upper_bound(brr + 1, brr + 1 + len, arr[i]) - brr;
            brr[pos] = arr[i];
        }
    }
    return len;
}

inline bool cmp (node a, node b)
{
    return a.x > b.x || a.x == b.x && a.y < b.y;
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        st.scan(); ed.scan();
        for (int i = 1; i <= n; ++i)
            point[i].scan();
        if (st.x > ed.x) swap(st, ed);
        if (st.y < ed.y)
        {
            sort(point + 1, point + 1 + n);
            int cnt = 0;
            for (int i = 1; i <= n; ++i)
            {
                if (point[i].x >= st.x && point[i].x <= ed.x && point[i].y >= st.y && point[i].y <= ed.y)
                    arr[++cnt] = point[i].y;
            }
            printf("%d
", DP1(cnt));
        }
        else
        {
            sort(point + 1, point + 1 + n, cmp);
            int cnt = 0;
            for (int i = 1; i <= n; ++i)
            {
                if (point[i].x >= st.x && point[i].x <= ed.x && point[i].y >= ed.y && point[i].y <= st.y)
                    arr[++cnt] = point[i].y;
            }
            printf("%d
", DP1(cnt));
        }
    }
    return 0;
}