大意：
给定一个有 n 个点 n 条边的无向带权图，保证 n 为 6 的倍数，组成 n/3个三元环： (1,2,3),(4,5,6),⋯。
现在给每个点染上红或蓝两种颜色，要求红色有 n/2 个点、蓝色也有 n/2 个点 。
定义一种染色方案的价值为，两端颜色不同的边的权值总和。
设所有染色方案种价值最大为 W ，问有多少种染色方案的价值为 W 。
思路：
感觉这是见过的D题里面最直白的了...
显然不同环之间互不干扰，我们分开看
每一个三元环里面想要有贡献的话，一定是取两个最大的边相加，要做到这一步，我们需要给环染成黑白比为2:1，或者反一反。那么最大值显然就是所有环的最大值之和。接下来考虑方案数，那就是看每一个环达到最大值有几种方法，乘一下就好了。
考虑到在这种策略下每一个环会让黑白的颜色数差1，又因为环数是偶数（n%6=0），所以取一半是黑色即可。
所以总的方案数=（每一个环的方案数）*C(环数，环数/2);
做题的时候顺便考虑了一下环数为奇数的情况：
不难发现此时为了满足有一半是黑色，必须要有一个环全部染成黑色/白色，也就是有一个环必须抛弃。那么我们抛弃价值最小的就好了。然后该怎么做怎么做。
code
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
const ll N=3e5+10;
const ll mod=998244353;
ll n;
struct ty
{
ll a,b,c;
ll val;
ll gt()
{
if(a==b&&b==c) return 3;
if(a<b) swap(a,b);if(a<c) swap(a,c);if(b<c) swap(b,c);
if(a==c||b==c) return 2;
return 1;
}
}mas[N];
ll min(ll a,ll b,ll c)
{
return min(a,min(b,c));
}
ll p[N];
ll pp[N];
ll ksm(ll x,ll y)
{
ll ans=1;
while(y)
{
if(y&1) ans=ans*x%mod;
x=x*x%mod;
y>>=1;
}
return ans;
}
ll inv(ll x)
{
return ksm(x,mod-2);
}
void init()
{
p[0]=1;
for(int i=1;i<=100000;++i) p[i]=p[i-1]*i%mod;
pp[100000]=inv(p[100000]);
for(int i=100000-1;i>=0;--i) pp[i]=pp[i+1]*(i+1)%mod;
}
void solve()
{
init();
cin>>n;
n/=3;
for(int i=1;i<=n;++i)
{
cin>>mas[i].a>>mas[i].b>>mas[i].c;
mas[i].val=mas[i].a+mas[i].b+mas[i].c-min(mas[i].a,mas[i].b,mas[i].c);
}
ll mi=1e9,sum=0,pos=0;
ll cnt=0;
ll kl=0;
for(int i=1;i<=n;++i)
{
if(mi>mas[i].val)
{
mi=min(mi,mas[i].val);
pos=i;
}
else if(mi==mas[i].val&&mas[pos].gt()>mas[i].gt())
{
mi=mas[i].val;
pos=i;
}
}
// for(int i=1;i<=n;++i) cout<<mas[i].gt()<<" ";
// cout<<endl;
if(n%2) kl=pos;
ll ans=1;
for(int i=1;i<=n;++i)
{
if(i==kl) continue;
ans=ans*mas[i].gt()%mod;
}
if(n%2) n--;
ans=ans*p[n]%mod*pp[n/2]%mod*pp[n/2]%mod;
cout<<ans<<endl;
}
int main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
//ll t;cin>>t;while(t--)
solve();
return 0;
}大意：
有 n个怪物，第 i 个怪物的血量有 hi ，血量降为 0 时立刻死亡，你有两种攻击方式：
-
指定一个怪物，对其普通攻击，造成 1 点伤害，消耗 1 点魔法。普通攻击可以使用无限次。
-
指定一个怪物，对其释放爆炸魔法，造成的伤害取决于注入的魔法，如果想要消耗 x 点魔法注入其中，会造成 x 点伤害。
爆炸魔法具有连锁性，如果被魔法击中的怪物死了，假设是第 i 个怪物，那么i−1,i+1 两个怪物会受到 hi−1 的伤害，以此类推，直至没有怪物死掉。这个魔法只能使用一次。
问，最少需要多少魔法能消灭所有怪物。
思路：
显然的，我们会希望第二种技能能造成的伤害越高越好。剩余部分就用第一种伤害补齐就行了
不妨naive地考虑一下暴力：
对于每一个位置i，观察在该处使用第二种技能的最大伤害（这里指我们在经过一系列第一个技能之后使用该技能）。我们先考虑位置i的左边：在最理想的情况下，在位置j释放的伤害应该能够达到hi-(i-j),可以自己手推一下。那么，如果hj>=hi-(i-j),那么我们在一开始用第一技能把它削到可以被第二技能打死的地步，它就能持续对更左边造成伤害了。hj<hi-(i-j)时，j怪能死，但是向左传递的最高伤害就变了，我们记L[]表示位置向左的最高伤害，那么此时L[i]=L[j]+val(i,j),这个val代表区间总伤害，这时一个等差数列求和，我就不算了。
这是n^2的，考虑优化。一个很常见的思路就是相同变量放到一边去，我们就得到了伤害传递的判断式:
hj-j<hi-i (j<i)
此时就很显然了，对于一个i，我们找到最左边的j满足上述判断式，那么L[i]=L[i]=L[j]+val(i,j)
至于怎么找，显然维护一个单调不减的栈就可以了，具体见代码
这样我们就得到了每一个位置左边的最大伤害，右边同理。
最后每一个位置在最优操作下需要的总魔法就是sum-(L[i]-R[i]-hi)+hi,sum是总体血量，中间是一个小容斥，最后是第二个操作需要的魔法
这样我们从O(n^2)优化到了O(n)
code
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
const ll N=3e5+10;
const ll mod=998244353;
ll n;
ll mas[N];
ll h[N];
ll l[N],r[N];
ll sum=0;
void gt(ll *f)
{
stack<ll> st;
st.push(0);
for(int i=1;i<=n;++i)
{
while(st.size()>1&&h[st.top()]>=h[i]) st.pop();
ll len=i-st.top();
len=min(len,mas[i]);//太长了也不行
f[i]=f[st.top()]+len*(mas[i]+mas[i]-len+1)/2;
st.push(i);
}
}
void solve()
{
sum=0;
cin>>n;
for(int i=1;i<=n;++i) cin>>mas[i],h[i]=mas[i]-i,sum+=mas[i];
gt(l);
reverse(mas+1,mas+1+n);
for(int i=1;i<=n;++i) h[i]=mas[i]-i;
gt(r);
reverse(mas+1,mas+1+n);
reverse(r+1,r+1+n);
ll mi=1e18;
for(int i=1;i<=n;++i)
{
mi=min(mi,sum-l[i]-r[i]+mas[i]+mas[i]);
}
cout<<mi<<endl;
}
int main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
ll t;cin>>t;while(t--)
solve();
return 0;
}大意：
一棵树，n个点，有k个初始点是黑的，其余都是白的。按照顺序不断移动点，然后再是
...每次移动到相邻的一个白色节点，并将其染黑。问最多能走几步。
思路：
因为每一个点都是按顺序来移动的，所如果我们知道总步数的话，其实也可以很快知道每一个点应该走的步数。
val[i]=mid/k+(i<(mid%k)),这里我们从0开始数
所以考虑二分，然后判断是否每一个点的移动都能满足条件即可。
然后呢，这里有一个看似很好想，但其实不好想的结论（好一句废话
对于每一个点，能往下走就往下走。
对于两个不同子树上的点，如果有人往上走，就有可能跟别人的路径相撞。如果大家都能往下走，那自然就是皆大欢喜，因为只会在自己的子树里活动。如果跟别人在一颗子树里了，那就只能听天由命了。
注意到一旦往下走了就不能再往上了，所以我们需要一遍dfs来统计每一个点最多往下走几步。如果步数大于需要走的步数，那么这一个点就是可行的。否则，我们就只能向上走。
这显然就是写一个dfs。dfs的时候，先递归子树统计该点能向下走的最大步数。看看最大步数是否大于需要步数，可以的话就return 1，否则就要向上走。如果能向上走的话（父亲没有需要走的步数），就是将父亲的所需步数更新为该点所需步数-1.注意，一个父亲只能让一个儿子踩一遍，第二个儿子再过来就不能走了。这里可能会有一个疑问，会不会存在更优策略/遍历顺序使得两个儿子都能过去？不会。两个儿子都要向上走，意味着它们都无法向下走，都只有一个决策。而不管是谁向上走，都有一个不能走了，此时二分的判断条件也就已经判否了（所有点都要满足条件），就没有讨论的必要了。
时间复杂度O(nlogn)
code
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
const ll N=2e5+20;
const ll mod=998244353;
ll n,k;
vector<ll> vt[N];
ll gt[N];//还能向下走几步
ll vis[N];
ll val[N];
ll fl[N];
bool dfs(ll id,ll p)
{
gt[id]=0;
for(auto i:vt[id])
{
if(i==p) continue;
if(!dfs(i,id)) return 0;//有一个不行就全部失败
if(!vis[i]) gt[id]=max(gt[id],gt[i]+1);
}
if(gt[id]>=val[id]) return 1;//能向下走就向下走
if(p==-1||vis[p]) return 0;
vis[p]=1;//标记走过 ,防止不同有标记的儿子抢一个父亲
val[p]=val[id]-1;
return 1;
}
bool judge(ll x)
{
for(int i=0;i<=n+10;++i) vis[i]=0,val[i]=0,gt[i]=0;
for(int i=0;i<k;++i)
{
val[fl[i]]=x/k+(i<(x%k));
vis[fl[i]]=1;
}
// cout<<x<<' 'x%k<<' ';
// for(int i=1;i<=k;++i) cout<<val[fl[i]]<<' ';
// cout<<endl;
return dfs(0,-1);
}
void solve()
{
cin>>n;
for(int i=0;i<=n+10;++i)
{
vt[i].clear();
gt[i]=vis[i]=val[i]=fl[i]=0;
}
for(int i=1;i<n;++i)
{
ll a,b;
cin>>a>>b;
a--;b--;
vt[a].push_back(b);
vt[b].push_back(a);
}
cin>>k;
for(int i=0;i<k;++i)
{
ll a;
cin>>fl[i];
fl[i]--;
}
ll l=1,r=n;
//cout<<"df ";
while(l<=r)
{
ll mid=l+r>>1;
//cout<<mid<<" ";
if(judge(mid)) l=mid+1;
else r=mid-1;
}
//cout<<endl;
cout<<l-1<<endl;
}
int main()
{
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
ll t;cin>>t;while(t--)
solve();
return 0;
}
608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
