T1
一道很水的题 其实对于本蒟蒻来说也没有那么水 只需要知道最小值总是会在零点的时候取到 因此将零点排序之后枚举当\(x=\)每个零点时 整个式子的值 然后用ans来存最小值。
需要注意的地方：1.因为我用的方法是用前缀和，后缀和优化，所以一定要将零点排序
2.当\(a=0\)的时候 零点算不出来。。我是将零点赋为极大值
3.当\(a<0\)的时候 将\(a,b\)都取反
因为在零点左边的所有式子一定大于零 在零点右边的式子一定小于零 所以可以用前缀和后缀和来实现
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define ll long long
using namespace std;
const ll maxn=300010;
const ll inf=0x3f3f3f3f;
ll read()
{
ll x=0,f=1;
char ch=getchar();
while(ch<'0' || ch>'9')
{
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0' && ch<='9')
{
x=x*10+ch-'0';
ch=getchar();
}
return x*f;
}
ll n,prea[maxn],preb[maxn],sufa[maxn],sufb[maxn];
ll a[maxn],b[maxn];
struct node{
ll prea,preb,sufa,sufb,id,a,b;
long double zero;
#define prea(x) job[x].prea
#define preb(x) job[x].preb
#define sufa(x) job[x].sufa
#define sufb(x) job[x].sufb
#define id(x) job[x].id
#define a(x) job[x].a
#define b(x) job[x].b
}job[maxn];
long double ans=999999999999999,now,bj;
inline bool cmp(node x,node y)
{
return x.zero<y.zero || (x.zero==y.zero && x.id<y.id);
}
int main()
{
freopen("spongebob.in","r",stdin);
freopen("spongebob.out","w",stdout);
n=read();
for(ll i=1;i<=n;i++)
{
a(i)=read(),b(i)=read();
if(a(i)<0){
a(i)=-a(i);b(i)=-b(i);
}
else if(a(i)==0){
job[i].zero=0x3f3f3f3f*1.0;
}
job[i].zero=-1.0*(double)b(i)/(double)a(i);
}
sort(job+1,job+1+n,cmp);
for(int i=1;i<=n;i++)
{
prea(i)=prea(i-1)+a(i);
preb(i)=preb(i-1)+b(i);
}
for(ll i=n;i>=1;i--)
{
sufa(i)=sufa(i+1)+a(i);
sufb(i)=sufb(i+1)+b(i);
}
for(ll i=1;i<=n;i++)
{
now=0;
now=job[i].zero*prea(i)*1.0+preb(i)*1.0-job[i].zero*sufa(i)*1.0-sufb(i)*1.0;
if(ans>now) ans=now,bj=job[i].zero;
}
printf("%.5f",(double)ans);
return 0;
}
T2
这道题暴力可以拿\(30pts\)呢！ 所以说为什么我的分块才\(20pts\)！蒟蒻表示一脸懵逼
那么暴力的方法就不用说了吧 每次都扫描一遍。
然后我们来看正解
首先分析如果对于任意的\(i∈[0,n-1]\),\(h[i] < h[i+ 1]\) 均可以对\([a[i]+1,a[i+1]]\)造成一点贡献 当水平线到了\([a[i]+1,a[i+1]]\)时，因为\(a[i]\)小于该区间,\(a[i+1]\)等于该区间 所以当水平线在这个范围内 相当于会新增加一个岛屿 所以最终你需要输出的答案就是当前水平线对应的值是多少
因为这个是待修的 所以可以用线段树和树状数组
那么接下来就上代码啦！
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn=600010;
int read()
{
int x=0,f=1;
char ch=getchar();
while(ch<'0' || ch>'9')
{
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0' && ch<='9')
{
x=x*10+ch-'0';
ch=getchar();
}
return x*f;
}
int h[maxn],n,m;
int tree[maxn];
int last=0;
int lowbit(int x)
{
return x&(-x);
}
void add(int x,int val)
{
x++;
for(;x<=maxn;x+=lowbit(x))
tree[x]+=val;
}
int query(int x)
{
int ans=0;
for(;x;x-=lowbit(x))
ans+=tree[x];
return ans;
}
int main()
{
n=read();m=read();
for(int i=1;i<=n;i++)
h[i]=read();
for(int i=1;i<=n;i++)
{
if(h[i-1]<h[i])
{
add(h[i-1],1);
add(h[i],-1);
}
}
for(int i=1;i<=m;i++)
{
char type;
scanf("%s",&type);
if(type=='Q')
{
int q=read();
q=q^last;
printf("%d\n",last=query(q));
}
else
{
int x=read(),y=read();
x=x^last;y=y^last;
if(h[x-1]<h[x])
{
add(h[x-1],-1);add(h[x],1);
}
if(h[x]<h[x+1])
{
add(h[x],-1);add(h[x+1],1);
}
h[x]=y;
if(h[x-1]<h[x])
{
add(h[x-1],1);
add(h[x],-1);
}
if(h[x]<h[x+1])
{
add(h[x],1);
add(h[x+1],-1);
}
}
}
return 0;
}
T3
这道题 我觉得我不会很正常(会了才奇怪呢)
暴力：每一条边都枚举其情况 复杂度\(O(2^m),20pts\)
正解：首先易证：此题肯定有解！
对于每一个点如果同一个权值的边出现了两次 那么就可以考虑将这两条边删了 加入一条新的边 关于这道题的细节真的很多 具体的话看代码 我tm原地转圈圈懵逼
#include<bits/stdc++.h>
using namespace std;
#define in read()
int in{
int cnt=0,f=1;char ch=0;
while(!isdigit(ch)){
ch=getchar();if(ch=='-')f=-1;
}
while(isdigit(ch)){
cnt=cnt*10+ch-48;
ch=getchar();
}return cnt*f;
}
struct node{
int id,to,d;
}a[2][2000003];
int n,m;
int depend[2000003];
int rev[2000003];
//rev 数组 解决的问题是 在最后的时候 ans[i] 由其 depend的边转换过来时 是否需要取反
int ans[2000003];int tot;
void add(int x,int y,int id,int r){//x,y表示连接的点 id表示正在加入第i条边 r表示权值
node*q=a[r];// q表示所有的 权值为r的边
//q[x].id 表示当前x 的边的编号
//q[x].to 表示当前边指向的点
if(q[x].id&&q[x].to==y){//相当于 两个点 之间连了 两条边 都要删掉
depend[q[x].id]=depend[id]=0;//当前正在加入的边 和 之前该点对应的边 的依靠 为0
ans[id]=1;ans[q[x].id]=q[y].d;//当前边ans 设为 1 之前边 ans 设为 y的上一条边的 方向
q[x].id=q[y].id=0;//把他们的id 设为 0 相当于删边
return;
}
int flag=1;
if(q[x].id){//如果 x 之前有边
flag=0;
depend[q[x].id]=tot;// 那么x之前的边 依靠于新边
rev[q[x].id]=q[x].d;//rev 对于x来说 他之前边的方向 与 其指向相同
//而在实际计算中后面对ans 的计算中 其实是取反了的84行
//因为对于q[x].id这条边来说 他与新加入的边的关系 相同的
//若 d==1 则相当于之前的边是指向 x的
//若 新边的方向为 0 那么 这一条边的方向不变
//否则 会改变
//建议手玩一下
q[x].id=0;//把x 之前的边 删了
x=q[x].to;//将x指向 之前边指向的另一个点
}
//与 x同理
if(q[y].id){
flag=0;
depend[q[y].id]=tot;
rev[q[y].id]=q[y].d^1; //这里与x刚好相反
q[y].id=0;
y=q[y].to;
}
q[x].to=y;q[y].to=x;//互相 成为 对方到达的点
q[x].d=1;q[y].d=0;//钦定方向 默认 从 x -> y的 方向
if(flag)q[x].id=q[y].id=id; //他们的 id 相当于 当前加入的边
else{
q[x].id=q[y].id=depend[id]=tot++;//将他们的 id 设为 新点 并且 将他们的依靠 设为新边
//至于关于depend的疑惑 实际在 38 和 42行就已经处理过了
}
//相当于 如果 flag == 0 就先当于 加边之后有环了 所以可以将xy对应的之前的边以及当前加入的边 依靠在新边上
}
int vis[2000003];
void work(int u){
int x=u,t=0;
vis[x]=1;
//t是权值 x是点 a[t][x]相当于 x点在权值t下 对应的唯一一条边
//这里相当于从边权为1的边开始走
while(a[t][x].id){
ans[a[t][x].id]=a[t][x].d;//先 将当前边的ans暂且的设为该边本身的方向
if(vis[a[t][x].to])return;//如果出现环了 就返回 因为继续走下去 他还是个环。
// 不用担心ans没更新完 因为主函数里面 是一个for 循环
vis[a[t][x].to]=1;
x=a[t][x].to;t^=1;
}
//这里相当于从边权为2的边开始走
x=u;t=1;
while(a[t][x].id){
ans[a[t][x].id]=a[t][x].d^1;
if(vis[a[t][x].to])return;
vis[a[t][x].to]=1;
x=a[t][x].to;t^=1;
}
}
signed main(){
n=in;m=in;tot=m+1;
for(int i=1;i<=m;i++){
int a=in;int b=in;int c=in;
add(a,b,i,c-1);//第i条边 对应c-1的权值 连接的是a,b
}
for(int i=0;i<n;i++)if(!vis[i])work(i);
for(int i=tot;i>0;i--){
if(depend[i])ans[i]=ans[depend[i]]^rev[i];//rev 如果为1 就要取反 否则 就不取反
}
for(int i=1;i<=m;i++)cout<<ans[i];
return 0;
}
