牛客国庆集训派对Day3 Solution

A    Knight

留坑。

B    Tree

思路：两次树形DP，但是要考虑0没有逆元

可以用前缀后缀做

#include <bits/stdc++.h>
using namespace std;
 
#define N 1000010
#define ll long long
 
const ll MOD = (ll)1e9 + 7;
 
 
int n;
ll dp[N], dp2[N];
ll prefix[N], suffix[N];
vector <int> G[N]; 
 
void Init()
{
    for (int i = 1; i <= n; ++i) dp[i] = 1, dp2[i] = 0, G[i].clear();
}
 
void DFS(int u, int fa)
{
    for (auto v : G[u])
    {
        if (v == fa) continue;
        DFS(v, u);
        dp[u] = dp[u] * (dp[v] + 1) % MOD;
    }
}
 
void DFS2(int u, int fa)
{
    prefix[0] = 1;
    suffix[G[u].size() + 1] = 1;
    int len = G[u].size();
    for (int i = 0; i < len; ++i)
    {
        int v = G[u][i];
        if (v == fa) prefix[i + 1] = prefix[i];
        else prefix[i + 1] = prefix[i] * (dp[G[u][i]] + 1) % MOD;
    }
    for (int i = len - 1; i >= 0; --i)
    {
        int v = G[u][i];
        if (v == fa) suffix[i + 1] = suffix[i + 2];
        else suffix[i + 1] = suffix[i + 2] * (dp[G[u][i]] + 1) % MOD;
 
    }
    for (int i = 0; i < len; ++i) 
    {
        int v = G[u][i];
        if (v == fa) continue; 
        dp2[v] = prefix[i] % MOD * suffix[i + 2] % MOD * (dp2[u] + 1) % MOD; 
    }
    for (auto v : G[u])
    {
        if (v == fa) continue;
        DFS2(v, u);
    }
}
 
void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        Init();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1, 0); DFS2(1, 0);
        for (int i = 1; i <= n; ++i) printf("%lld
", dp[i] * (dp2[i] + 1) % MOD);
    }
}
 
int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif
 
    Run();
    return 0;
}

C    Two Graphs

留坑。

D    Shopping

贪心即可。

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

#define N 1010

int t, n, m;
int arr[N], res;

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        res = 0;
        scanf("%d%d", &n, &m);
        for (int i = 1, b; i <= n; ++i) 
        {
            scanf("%d%d", arr + i, &b);
            if (b) ++res;
        }
        sort(arr + 1, arr + 1 + n);
        res = min(res, m);
        double ans = 0;
        for (int i = n; i >= 1; --i, --res)
            ans += res > 0 ? arr[i] * 1.0 / 2 : arr[i];
        printf("%.1f
", ans);
    }
    return 0;
}

E    Trophies

留坑。

F    Palindrome

留坑。

G    Stones

留坑。

H    Travel

思路：隔板法，一条边相当于划成两个区域。

#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
#define N 100010
 
const ll MOD = (ll)1e9 + 7;
 
ll fac[N];
 
void Init()
{
    fac[0] = 1;
    for (int i = 1; i < N; ++i) fac[i] = fac[i - 1] * i % MOD;
}
 
ll qpow(ll base, ll n)
{
    ll res = 1;
    while (n)
    {
        if (n & 1) res = res * base % MOD;
        base = base * base % MOD;
        n >>= 1;
    }
    return res;
}
 
ll C(ll n, ll m)
{
    if (m > n) return 0;
    return fac[n] * qpow(fac[m] * fac[n - m] % MOD, MOD - 2) % MOD;
}
 
int t, n, m;
 
int main()
{
    Init();
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1, a, b; i < n; ++i) scanf("%d%d", &a, &b);
        printf("%lld
", C(n - 1, m - 1) * fac[m] % MOD);
    }
    return 0;
}

I    Metropolis

思路：将所有大都会都放到最短路去跑多源最短路，记录每个点的最短路是由哪个点扩展而来

显然，如果一个点源点i扩展到一个点j， 而点j又已经被点k扩展了，那么就没有必要扩展下去

我们在枚举每一条边，更新答案

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

#define N 200010
#define ll long long
#define INFLL 0x3f3f3f3f3f3f3f3f

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

int n, m, p;
int head[N], pos;
int x[N], Belong[N];
ll dis[N], ans[N];

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

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

priority_queue <node> q;

void Init()
{
    memset(head, -1, sizeof head);
    pos = 0;
    while (!q.empty()) q.pop();
    memset(Belong, 0, sizeof Belong);
    memset(ans, 0x3f, sizeof ans);
}

void Dijkstra()
{
    while (!q.empty())
    {
        node top = q.top(); q.pop();
        if (Belong[top.v]) continue;
        Belong[top.v] = top.u;
        dis[top.v] = top.w; 
        for (int it = head[top.v]; ~it; it = edge[it].nx)
        {
            int v = edge[it].to;
            q.emplace(top.u, v, top.w + edge[it].w);
        }
    }
}

void Run()
{
    while (scanf("%d%d%d", &n, &m, &p) != EOF) 
    {
        Init();
        for (int i = 1; i <= p; ++i)
        {
            scanf("%d", x + i);
            q.emplace(x[i], x[i], 0);
        }
        for (int i = 1, u, v, w; i <= m; ++i)
        {
            scanf("%d%d%d", &u, &v, &w);
            addedge(u, v, w);
            addedge(v, u, w);
        }
        Dijkstra(); 
        for (int u = 1; u <= n; ++u)
        {
            for (int it = head[u]; ~it; it = edge[it].nx)
            {
                int v = edge[it].to;
                ll w = edge[it].w;
                if (Belong[u] == Belong[v]) continue;
                ans[Belong[u]] = min(ans[Belong[u]], dis[u] + dis[v] + w);
                ans[Belong[v]] = min(ans[Belong[v]], dis[u] + dis[v] + w); 
            }
        }
        for (int i = 1; i <= p; ++i) printf("%lld%c", ans[x[i]], " 
"[i == p]);
    }
}

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

    Run();
    return 0;
}

J    Graph Coloring I

思路：对于一张图，如果没有奇圈，那么肯定可以用两种颜色进行染色，那么肯定有解

只要去找奇圈即可。

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

#define N 300010

int n, m;
vector <int> G[N], ans;
int deep[N], fa[N];
bool flag;

void DFS(int u)
{
    if (flag) return; 
    for (auto v : G[u])
    {
        if (flag) return;
        if (v == fa[u]) continue;
        if (fa[v] != -1 && !flag)
        {
            if ((deep[u] - deep[v]) % 2 == 0)
            {
                ans.push_back(u);
                while (u != v)
                {
                    u = fa[u];
                    ans.push_back(u);
                }
                flag = true;
                return;
            }
        }
        else
        {
            fa[v] = u;
            deep[v] = deep[u] + 1;
            DFS(v);     
        }
    }
}

void Init()
{
    for (int i = 1; i <= n; ++i) G[i].clear(); 
    ans.clear();
    memset(fa, -1, sizeof fa); 
    deep[1] = 0;     
    flag = false;
}

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        Init();
        for (int i = 1, u, v; i <= m; ++i) 
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1);
        if (flag)
        {
            printf("%d
", (int)ans.size());
            for (int i = 0, len = ans.size(); i < len; ++i) printf("%d%c", ans[i], " 
"[i == len - 1]);
        }
        else
        {
            puts("0");
            for (int i = 1; i <= n; ++i) printf("%d%c", deep[i] & 1, " 
"[i == n]);
        }
    }
    return 0;
}

K    Graph Coloring II

留坑。