AtCoder - ABC 267 - E（二分/贪心）
E - Erasing Vertices 2
题意：
给定一个有 n 个点 m 条边无向图，每个点都有权值。每次要删除一个点及其所连的所有边，删除某点的代价是与这个点直接相邻的所有点的权值和，使 n 次删除操作后的最大值最小，求其最小值。
数据范围：
1 ≤ N ≤ 2 × 
0 ≤ M ≤ 2 ×
1 ≤ Ai ≤ 
1 ≤ Ui,Vi ≤ N
思路1：（二分）
求最大值的最小值，典型的二分问题。
通过搜索将代价小于等于当前二分的值的点删除，如果所有点最终都能被删除，说明当前二分的代价可行。
实现：1.这里用的是邻接表存图；数组w记录删除某点的代价；数组st表示节点是否被删除过。
2.用队列实现先将代价小于等于当前二分的值x的点删掉，将这样的点入队后。从头遍历队列，执行删除队头节点后将与该点直接相连的所有节点的代价值更新，再判断更新后的点的代价是否小于等于 x，如果是，入队表示该点可以作为在代价值为 x 时删除的节点。
3.最后判断是否存在节点未被删除，如果存在，说明当前的 x 太小，继续进行二分枚举。
Code:
#include
#include
#include
#include
#include
using namespace std;
const int N = 200010;
#define int long long
int n, m;
int a[N];
int h[N], e[2 * N], ne[2 * N], idx;
//邻接表存图
void add(int a, int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
bool check(int x)
{
vectorw(n + 1); //数组w[j]记录节点j被删除的代价，即点j与其直接相连的所有点的权值之和
for (int i = 1; i <= n; i++) //i表示枚举的起点
for (int j = h[i]; ~j; j = ne[j]) //枚举的j对应的是直接与起点i相连的点
w[e[j]] += a[i]; //因为j与i相连，所以预处理j对应的节点代价时，算上i节点的权值
queueq;
for (int i = 1; i <= n; i++)
if (w[i] <= x)
q.push(i); //将价值比此时枚举到的答案x小于等于的节点，考虑为所要删除的点
vectorst(n + 1); //标记数组，用来记录节点是否被删除过
while (q.size())
{
int u = q.front(); //取队头来遍历队列
q.pop();
if (st[u])continue; //如果该节点已经删除过，跳过
st[u] = true; //标记下
for (int i = h[u]; ~i; i = ne[i]) //要删除点u，遍历所有与节点u相连的节点
{
int j = e[i]; //j即表示与节点u直接相连的点
if (st[j])continue;
w[j] -= a[u]; //删除节点u后，节点j的代价减去节点u的权值
if (w[j] <= x)q.push(j); //判断此时的节点j可以作为删除点，如果是入队
}
}
for (int i = 1; i <= n; i++)if (!st[i])return false; //如果最后有节点没有标记过，说明要删除该节点所需的代价大于x，继续二分增更大的x的
return true;
}
void solve()
{
cin >> n >> m;
memset(h, -1, sizeof(h));
for (int i = 1; i <= n; i++)cin >> a[i]; //输入n个点的权值
while (m--)
{
int a, b;
cin >> a >> b;
add(a, b), add(b, a); //创建边
}
int l = -1, r = 1e18;
while (l < r)
{
int mid = l + r >> 1;
if (check(mid))r = mid;
else l = mid + 1;
}
cout << l << endl;
}
signed main()
{
int t = 1;
//cin >> t;
while (t--)
{
solve();
}
return 0;
} 思路2：（贪心）
如何贪心最优：
因为删除节点的顺序对最后图的结构是没有影响的，即最终 n 个节点都会被删除。所以我们每次选点操作时应该尽量先删去代价小的节点，这样不会使得之后的操作更劣，这就是最优的贪心做法。
如何动态更新操作后选择代价最小的节点呢：
朴素做法会超时 O(n^2)，我们可以考虑用小根堆，即优先队列来优化。将 n 个节点的代价入队，每取队头进行删除操作后，将与该节点直接相连的点的代价更新。将更新后的值入队。这样在删除点的过程中，所需的的最大代价就是要求的最大值的最小值。
实现：1.这里是用二维数组存的图；优先队列存的是节点的代价及节点编号；数组w记录删除某点的代价；数组st表示节点是否被删除过。
2.将所有节点都入队后，每次取堆顶节点进行删除操作，记录每次删除的代价，最后取Max即最终答案；同理将与被删除节点直接相连的其他节点的代价值更新后，再次入队。
时间复杂度：O(logn)
Code:
#include
#include
#include
#include
#include
using namespace std;
#define x first
#define y second
#define int long long
const int N = 200010;
typedef pairPII;
int n, m;
int a[N], w[N];
bool st[N];
vectorG[N];
void solve()
{
cin >> n >> m;
for (int i = 1; i <= n; i++)cin >> a[i];
while (m--)
{
int a, b;
cin >> a >> b;
//用二维数组G存储树
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++)
for (auto v : G[i])
w[i] += a[v]; //用数组w记录删除节点的代价
priority_queue, greater>pq; //优先队列（小根堆），每个元素类型是PII
for (int i = 1; i <= n; i++)pq.push(make_pair(w[i], i)); //将每个节点及代价入队，代价在前，优先代价排序
int ans = 0;
while (!pq.empty())
{
PII now = pq.top(); //按代价最小的点先删除；即每次先取堆顶元素
pq.pop();
if (st[now.y])continue;
st[now.y] = true; //st数组记录节点是否被删除
ans = max(ans, now.x); //贪心下求最大价值即最终答案最小的最大值
for (auto v : G[now.y]) //枚举与节点now直接相连的节点v
{
w[v] -= a[now.y]; //将节点v更新为删除节点now后的代价
pq.push(make_pair(w[v], v)); //将节点v入队
}
}
cout << ans << endl;
}
signed main()
{
int t = 1;
//cin >> t;
while (t--)
{
solve();
}
return 0;
} ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
吐槽：想到用二分，但是check的思路无啊。题目注意点：
1.二分和贪心代码上其实有相似性的，尤其是删除点的相关操作，类似于 Dijkstra 算法，边操作边更新。
2.贪心代码中的make_pair函数倒是第一次见，感觉挺好用。还有注意pair排序优先first。