洛谷1197 [JSOI2008]星球大战

洛谷1197 [JSOI2008]星球大战
本题地址: http://www.luogu.org/problem/show?pid=1197

题目描述
很久以前,在一个遥远的星系,一个黑暗的帝国靠着它的超级武器统治者整个星系。某一天,凭着一个偶然的机遇,一支反抗军摧毁了帝国的超级武器,并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长,很快帝国又重新造出了他的超级武器。凭借这超级武器的力量,帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁,两个星球之间的通讯通道也开始不可靠起来。现在,反抗军首领交给你一个任务:给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序,以尽量快的速度求出每一次打击之后反抗军占据的星球的连通快的个数。(如果两个星球可以通过现存的以太通道直接或间接地连通,则这两个星球在同一个连通块中)。
输入输出格式
输入格式:
输入文件第一行包含两个整数,N (1 <= N <= 2M) 和M (1 <= M <= 200,000),分别表示星球的数目和以太隧道的数目。星球用0~N-1的整数编号。
接下来的M行,每行包括两个整数X, Y,其中(0<=X<>Y < N),表示星球X和星球Y之间有以太隧道。注意所有的以太隧道都是双向的。
接下来一行是一个整数K,表示帝国计划打击的星球个数。
接下来的K行每行一个整数X,满足0<=X< N,表示帝国计划打击的星球编号。帝国总是按输入的顺序依次摧毁星球的。

输出格式:
输出文件的第一行是开始时星球的连通块个数。
接下来的K行,每行一个整数,表示经过该次打击后现存星球的连通块个数。

输入输出样例
输入样例#1:
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
输出样例#1:
1
1
1
2
3
3
说明
[JSOI2008]

—————————华丽的分割线—————————-

题解:
这道题有点意思…首先看到连通块这个次就应该敏感的想到并查集,正如我在洛谷P1111中所说的,先前我还以为这道题是求割点的题,后来发现确实是简单的并查集就可以了,不过要反过来做(其实是百度时画面一闪而过的“逆向思维”点醒了我),我的做法就是把摧毁星球反过来,因为并查集只能实现合并,那么我们把过程反过来做即为建立星球,那么只要输入时实现建好图就可以了。

我的程序

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>

using namespace std;
const int maxn=400010;
int fa[maxn];
vector<int> G[maxn], ans; 
int a[maxn];
int vis[maxn];
int sum;
int find(int x){
    return fa[x] = (fa[x] == x) ? x : find(fa[x]);
}
void doit(int u)
{
    sum++; 
    vis[u]=true;
    for (int j=0; j<G[u].size(); j++)   //遍历所有儿子
    {
        int v=G[u][j];
        if (vis[v])
        {
            int fx=find(u), fy=find(v);
            if (fx!=fy)
            {
                fa[fy]=fx;
                sum--;
            }
        }
    }
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i=1; i<=m; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }

    for (int i=0; i<=n; i++) fa[i]=i;
    int K;
    scanf("%d", &K);
    memset(vis, 1, sizeof(vis));
    for (int i=1; i<=K; i++) scanf("%d", &a[i]), vis[a[i]]=0;
    sum=0;
    for (int i=0; i<n; i++) 
        if (vis[i]) doit(i);   //如果i属于没有被破坏的星球   计算当前连通块数

    ans.push_back(sum);
    for (int i=K; i>=1; i--) 
    {
        doit(a[i]);
        ans.push_back(sum);
    }
    for (int i=ans.size()-1; i>=0; i--) printf("%d\n", ans[i]);
}
根据引用[1],dp[u][j]表示在u子树中选取恰好j个人时能获得的最大价值。而根据引用,该问题的时间复杂度为O(log2​104×nm)。 对于洛谷P2143 [JSOI2010] 巨额奖金问题,我们可以使用动态规划来解决。具体步骤如下: 1. 首先,我们需要构建一棵树来表示员工之间的关系。树的根节点表示公司的总经理,其他节点表示员工。每个节点都有一个权值,表示该员工的奖金金额。 2. 接下来,我们可以使用动态规划来计算每个节点的dp值。对于每个节点u,我们可以考虑两种情况: - 如果选择节点u,则dp[u][j] = dp[v][j-1] + value[u],其中v是u的子节点,value[u]表示节点u的奖金金额。 - 如果不选择节点u,则dp[u][j] = max(dp[v][j]),其中v是u的子节点。 3. 最后,我们可以通过遍历树的所有节点,计算出dp[u][j]的最大值,即为所求的巨额奖金。 下面是一个示例代码,演示了如何使用动态规划来解决洛谷P2143 [JSOI2010] 巨额奖金问题: ```python # 构建树的数据结构 class Node: def __init__(self, value): self.value = value self.children = [] # 动态规划求解最大奖金 def max_bonus(root, j): dp = [[0] * (j+1) for _ in range(len(root)+1)] def dfs(node): if not node: return for child in node.children: dfs(child) for k in range(j, 0, -1): dp[node.value][k] = max(dp[node.value][k], dp[node.value][k-1] + node.value) for child in node.children: for k in range(j, 0, -1): for l in range(k-1, -1, -1): dp[node.value][k] = max(dp[node.value][k], dp[node.value][k-l-1] + dp[child.value][l]) dfs(root) return dp[root.value][j] # 构建树 root = Node(1) root.children.append(Node(2)) root.children.append(Node(3)) root.children[0].children.append(Node(4)) root.children[0].children.append(Node(5)) root.children[1].children.append(Node(6)) # 求解最大奖金 j = 3 max_bonus_value = max_bonus(root, j) print("最大奖金为:", max_bonus_value) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值