2016ACM/ICPC亚洲区沈阳站 Solution

A - Thickest Burger

水。

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

int t;
int a, b;

int main()
{
    scanf("%d" ,&t);
    while (t--)
    {
        scanf("%d%d", &a, &b);
        if (a > b) swap(a, b);
        printf("%d
", a + b * 2);
    }
    return 0;
}

B - Relative atomic mass

水。

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

int t;
char s[100];

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%s", s);
        int res = 0;
        for (int i = 0, len = strlen(s); i < len; ++i)
        {
            if (s[i] == 'H') res += 1;
            if (s[i] == 'C') res += 12;
            if (s[i] == 'O') res += 16;
        }
        printf("%d
", res);
    }
    return 0;
}

C - Recursive sequence

题意：求$F[n] = F[n - 1] + 2 cdot F[n - 2] + n^4$

思路：考虑

$n^4 = (n - 1)^4 + 4 cdot (n - 1) ^ 3 + 6 cdot (n - 1) ^2 + 4 cdot (n - 1) ^ 2 + (n - 1) + 1$

然后进行递推即可

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

#define ll long long

const ll MOD = 2147493647;

int t;
ll n, a, b;

struct node
{
    ll a[7][7];
    node () { memset(a, 0, sizeof a); }
    node operator * (const node &r) const
    {
        node ans = node();
        for (int i = 0; i < 7; ++i) for (int j = 0; j < 7; ++j) for (int k = 0; k < 7; ++k)
            ans.a[i][j] = (ans.a[i][j] + a[i][k] * r.a[k][j] % MOD) % MOD;
        return ans;
    }
};

ll tmp[7][7] = 
{
    1, 1, 0, 0, 0, 0, 0,
    2, 0, 0, 0, 0, 0, 0,
    1, 0, 1, 0, 0, 0, 0,
    4, 0, 4, 1, 0, 0, 0,
    6, 0, 6, 3, 1, 0, 0,
    4, 0, 4, 3, 2, 1, 0,
    1, 0, 1, 1, 1, 1, 1,
};

ll tmp2[7] = 
{
    0, 0, 16, 8, 4, 2, 1,
};

node qmod(ll n)
{
    node base = node();
    for (int i = 0; i < 7; ++i) for (int j = 0; j < 7; ++j)
        base.a[i][j] = tmp[i][j];
    node res = node();
    for (int i = 0; i < 7; ++i) res.a[0][i] = tmp2[i];
    while (n)
    {
        if (n & 1) res = res * base;
        base = base * base;
        n >>= 1;
    }
    return res;
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld%lld%lld", &n, &a, &b);
        if (n == 1) printf("%lld
", a);
        else if (n == 2) printf("%lld
", b);
        else
        {
            tmp2[0] = b; tmp2[1] = a;
            printf("%lld
", qmod(n - 2).a[0][0]);
        }
    }
    return 0;
}

D - Winning an Auction

留坑。

E - Counting Cliques

题意：给出n个点，m条边，求点集大小为S的完全图个数

思路：以每个点为起点搜有多少完全图

#include<bits/stdc++.h>

using namespace std;

const int maxn = 1e2 + 10;

int n, m, s;
int ans;
int arr[maxn], tot;
int mp[maxn][maxn];
vector<int>G[maxn];

void Init(int N)
{
    ans = 0;
    for(int i = 1; i <= N; ++i)
    {
        G[i].clear();
        mp[i][i] = 1;
        for(int j = i + 1; j <= N; ++j)
        {
            mp[i][j] = mp[j][i] = 0;
        }
    }
}

void DFS(int u, int cnt)
{
    if(cnt == s)
    {
        ++ans;
        return ;
    }
    for(auto it: G[u])
    {
        bool flag = true;
        for(int i = 0; i < tot; ++i)
        {
            if(!mp[arr[i]][it]) 
            {
                flag = false;
                break;
            }
        }
        if(flag)
        {
            arr[tot++] = it;
            DFS(it, cnt + 1);
            tot--;
        }
    }
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d %d", &n, &m, &s);
        Init(n);
        for(int i = 1; i <= m; ++i)
        {
            int u, v;
            scanf("%d %d", &u, &v);
            G[u].push_back(v);
            mp[u][v] = mp[v][u] = 1;
        }
        for(int i = 1; i <= n; ++i)
        {
            tot = 0;
            arr[tot++] = i;
            DFS(i, 1);
        }
        printf("%d
", ans);
    }
    return 0;
}

G - Do not pour out

题意：有一个底部为直径为2的圆，高度为2的桶，现在里面有高度为h的液体，将桶倾斜至最大，求上表面面积

思路：分类，若经过没经过底部则为PI / cos(2.0-d)

否则二分+积分求面积

#include<bits/stdc++.h>

using namespace std;

const double eps = 1e-20;
const double PI = acos(-1.0);

int sgn(double x)
{
    if(fabs(x) < eps) return 0;
    else return x > 0 ? 1 : -1;
}

double d;

double calc(double arc)
{
    return PI * cos(arc) - arc * cos(arc) + sin(arc) - sin(arc) * sin(arc) * sin(arc) / 3.0;
}

int check(double mid)
{
    double tmp = (calc(acos(2.0 * tan(mid) - 1.0)) - calc(PI)) / tan(mid);
    return sgn(tmp - d * PI);
}

double get(double l, double r)
{
    if(check(l) == 0) return l;
    int cnt = 256;
    while(cnt--)
    {
        double mid = (l + r) / 2.0;
        int tmp = check(mid);
        if(tmp == 0) return mid;
        if(tmp == 1) r = mid;
        if(tmp == -1) l = mid;
    }
    return l;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%lf", &d);
        if(sgn(d) == 0)
        {
            printf("0.00000
");
        }
        else if(sgn(d - 1) > 0)
        {
            double arc = atan(2.0 - d);
            double ans = PI / cos(arc);
            printf("%.5f
", ans);
        }
        else
        {
            double tmp = get(eps, PI / 4.0);
            double t1 = 2.0 * tan(tmp) - 1.0;
            double arc = acos(t1);
            double ans = PI - arc + cos(arc) * sin(arc);
            ans = ans / sin(tmp);
            printf("%.5f
", ans);
        }
    }
    return 0;
}

H - Guessing the Dice Roll

留坑。

I - The Elder

题意：给出一棵树，每个点到根节点1的方式可以是连续走，也可以经过一个点消耗时间p，使得重新计算所经过路径，求每个点到根节点最小的最大时间   时间为$L^2$

思路：考虑朴素的转移 $F[i] = min(F[j] + p + (sum[i] - sum[j]) ^ 2) (j 为 i 的祖先们)$

拆分式子

$F[i] = F[j] + p + {sum[i]} ^ 2 - 2 cdot sum[i] cdot sum[j] + {sum[j]} ^ 2$

$F[j] = F[i] + 2 cdot sum[i] cdot sum[j] - p - {sum[i]} ^ 2 - {sum[j]} ^ 2$

考虑斜率优化

树上的单调队列优化可以通过标记最后一个更改的值，然后还原(XHT)

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn = 1e5 + 10;

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

ll ans;
ll dis[maxn];
ll dp[maxn];
int n, p;
int que[maxn];
int head[maxn], tot;

void Init(int N)
{
    for(int i = 1; i <= N; ++i) head[i] = -1;
    tot = ans = 0;
}

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

ll dy(int j, int k)
{
    return dp[j] - dp[k] + dis[j] * dis[j] - dis[k] * dis[k];
}

ll dx(int j, int k)
{
    return 2 * (dis[j] - dis[k]);
}

void DFS(int u, int fa, int l, int r)
{
    int remind = -1;
    
    if(u != 1)
    {
        while(l < r && dy(que[l + 1], que[l]) <= dis[u] * dx(que[l + 1], que[l])) l++;
//        cout << u << " " << que[l] << " " << dp[que[l]] + p + (dis[u] - dis[que[l]]) * (dis[u] - dis[que[l]]) << endl;
        dp[u] = min(dis[u] * dis[u], dp[que[l]] + p + (dis[u] - dis[que[l]]) * (dis[u] - dis[que[l]]));
        while(l < r && dy(que[r], que[r - 1]) * dx(u, que[r]) >= dy(u, que[r]) * dx(que[r], que[r - 1])) r--;
        remind = que[++r];
        que[r] = u;
    }

    ans = max(ans, dp[u]);

    for(int i = head[u]; ~i; i = edge[i].nxt)
    {
        int v = edge[i].to;
        if(v == fa) continue;
        dis[v] = dis[u] + edge[i].w;
        DFS(v, u, l, r);
    }

    if(remind != -1) que[r] = remind;
}


int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &n, &p);
        Init(n);
        for(int i = 1; i < n; ++i)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v ,&w);
            addedge(u, v, w);
            addedge(v, u, w);
        }
        DFS(1, -1, 1, 0);
//        for(int i = 1; i <= n; ++i) cout << i << " " << dp[i] << endl;
        printf("%lld
", ans);
    }
    return 0;
}

J - Query on a graph

留坑。

K - New Signal Decomposition

留坑。

L - A Random Turn Connection Game

留坑。

M - Subsequence

留坑。