SCOI2015
这周各种头疼，一直睡觉+发呆，啥子都没干。
就补一下之前的东西。
d1t1小凸玩矩阵
一开始脑子抽写了最小费用最大流，不知道自己怎么想的。
第k大最小，明显的二分，又是二分图，二分第k大值，把小于它的边权值设为1，大于它的权值设为0跑最大流即可，也可以直接用匈牙利。
//Achen
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<queue>
#include<cmath>
const int N=1057;
typedef long long LL;
using namespace std;
int s,t,n,m,k,a[N][N],is[N][N],vis[N],pr[N],l=1e9,r=1;
template<typename T>void read(T &x) {
char ch=getchar(); x=0; T f=1;
while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
if(ch=='-') f=-1,ch=getchar();
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0'; x*=f;
}
int find(int x) {
for(int i=1;i<=m;i++) if(!vis[i]&&is[x][i]) {
vis[i]=1;
if(pr[i]==-1||find(pr[i])) {
pr[i]=x;
return 1;
}
}
return 0;
}
int ok(int x) {
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) {
if(a[i][j]>x) is[i][j]=0;
else is[i][j]=1;
}
int rs=0;
memset(pr,-1,sizeof(pr));
for(int i=1;i<=n;i++) {
memset(vis,0,sizeof(vis));
rs+=find(i);
}
return rs>n-k;
}
int main() {
#ifdef DEBUG
freopen(".in","r",stdin);
freopen(".out","w",stdout);
#endif
read(n); read(m); read(k);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) {
read(a[i][j]);
l=min(l,a[i][j]);
r=max(r,a[i][j]);
}
int ans=r;
while(l<=r) {
int mid=((l+r)>>1);
if(ok(mid)) ans=mid,r=mid-1;
else l=mid+1;
}
printf("%d\n",ans);
return 0;
}
d1t2国旗计划
先倍长破环为链。
记每个区间的nx，为左端点在这个区间左端点之后，右端点之前的，右端点最靠右的区间。那么每个区间的答案就是一直沿着nx跳直到覆盖的长度超过环长。
找nx,可以先把每个区间拆成左右端点，按pos排序，pos相同先排左端点。从左往右扫，扫到一个左端点就更新当前可以到达的右端点的最右值，扫到一个右端点就更新当前区间的答案。
扫一遍也就可以把第一个区间为起点的答案求出来了，记为k。
那么其他区间的答案肯定是k，k+1或者k-1。
把每个区间的nx设为它的父亲，建出一颗以第2*n个区间为根的树，那么每个区间的答案就是，判断它的第k个、第k-1个，第k+1个父亲到它能不能覆盖整个环长，选最近的父亲更新答案。
这个在dfs过程中把访问到的点都放进栈里就好了。
//Achen
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<queue>
#include<cmath>
const int N=1e6+7;
typedef long long LL;
using namespace std;
int n,m,k=1e9+7,l[N],r[N],ans[N],cnt,fa[N];
template<typename T>void read(T &x) {
char ch=getchar(); x=0; T f=1;
while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
if(ch=='-') f=-1,ch=getchar();
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0'; x*=f;
}
struct node {
int f,id;
LL pos;
node(){}
node(LL pos,int f,int id):pos(pos),f(f),id(id){}
friend bool operator <(const node &A,const node &B) {
return A.pos<B.pos||(A.pos==B.pos&&A.f<B.f);
}
}p[N];
int ecnt,fir[N],nxt[N],to[N];
void add(int u,int v) {
nxt[++ecnt]=fir[u]; fir[u]=ecnt; to[ecnt]=v;
}
int que[N],top=0;
void dfs(int x) {
que[++top]=x;
if(top&&top>=k-2) {
if(top>k&&r[que[top-k]]-l[x]>=m) ans[x]=min(ans[x],k+1);
if(top>k-1&&r[que[top-k+1]]-l[x]>=m) ans[x]=min(ans[x],k);
if(top>k-2&&r[que[top-k+2]]-l[x]>=m) ans[x]=min(ans[x],k-1);
}
for(int i=fir[x];i;i=nxt[i])
dfs(to[i]);
top--;
}
int main() {
#ifdef DEBUG
freopen(".in","r",stdin);
freopen(".out","w",stdout);
#endif
memset(ans,127,sizeof(ans));
read(n); read(m);
for(int i=1;i<=n;i++) {
read(l[i]); read(r[i]);
if(r[i]<=l[i]) r[i]+=m;
p[++cnt]=node(l[i],0,i);
p[++cnt]=node(r[i],1,i);
l[i+n]=l[i]+m; r[i+n]=r[i]+m;
p[++cnt]=node(l[i+n],0,i+n);
p[++cnt]=node(r[i+n],1,i+n);
}
sort(p+1,p+cnt+1);
int s=-1,now=1,mx=0,mxid,t,rt;
for(int i=1;i<=cnt;i++) {
if(p[i].f==0) {
if(s==-1) {
s=p[i].id; now=s; t=1; mxid=p[i].id;
}
if(r[p[i].id]>mx) mx=r[p[i].id],mxid=p[i].id;
}
else {
if(p[i].id==now) { t++; now=mxid; }
fa[p[i].id]=mxid;
}
if(r[now]-l[s]>=m) k=min(k,t);
}
for(int i=1;i<=2*n;i++) {
if(fa[i]!=i) add(fa[i],i);
else rt=i;
}
dfs(rt);
for(int i=1;i<=n;i++) printf("%d ",ans[i]);
return 0;
}
d1t3小凸想跑步
半平面交的模板题。
把需要的三角形面积小于其他每个三角形的式子列出来，就是一坨半平面的式子，直接半平面交求面积即可。
计算几何，模板打错最为致命。
//Achen
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<queue>
#include<cmath>
typedef long long LL;
typedef double db;
using namespace std;
const int N=3e5+7;
const db eps=1e-15;
int n,cnt,tot;
db ans;
template<typename T>void read(T &x) {
char ch=getchar(); x=0; T f=1;
while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
if(ch=='-') f=-1,ch=getchar();
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0'; x*=f;
}
struct pt {
db x,y;
pt(){}
pt(db x,db y):x(x),y(y){}
}p[N],T0,T1,T2,T3;
pt operator + (pt A,pt B) { return pt(A.x+B.x,A.y+B.y); }
pt operator - (pt A,pt B) { return pt(A.x-B.x,A.y-B.y); }
pt operator * (pt A,db p) { return pt(A.x*p,A.y*p); }
pt operator / (pt A,db p) { return pt(A.x/p,A.y/p); }
db dot(pt A,pt B) { return A.x*B.x+A.y*B.y; }
db cross(pt A,pt B) { return A.x*B.y-A.y*B.x; }
db length(pt A) { return sqrt(dot(A,A)); }
db dcmp(db x) { return (fabs(x)<eps)?0:(x<0?-1:1); }
struct Line {
pt a,b;
db slop;
friend bool operator <(const Line&A,const Line&B) {
return (A.slop<B.slop)||(A.slop==B.slop&&cross(A.b-A.a,B.b-A.a)<0);
}
}L[N],a[N];
db get_Area(int n) {
if(n<3) return 0;
db res=0; p[n+1]=p[1];
for(int i=1;i<=n;i++) res+=cross(p[i],p[i+1]);
return fabs(res)/2.0;
}
pt inter(Line A,Line B) {
pt rs;
db k1=cross(B.b-A.a,A.b-A.a);
db k2=cross(A.b-A.a,B.a-A.a);
db t=k1/(k1+k2);
rs.x=B.b.x+(B.a.x-B.b.x)*t;
rs.y=B.b.y+(B.a.y-B.b.y)*t;
return rs;
}
int ck(Line A,Line B,Line P) {
pt t=inter(A,B);
return cross(t-P.a,P.b-P.a)>0;
}
db solve(int n) {
sort(L+1,L+n+1);
tot=0;
for(int i=1;i<=n;i++)
if(i==1||L[i].slop!=L[i-1].slop) a[++tot]=L[i];
cnt=0; int ql=1,qr=0;
L[++qr]=a[1]; L[++qr]=a[2];
for(int i=3;i<=tot;i++) {
while(qr>ql&&ck(L[qr-1],L[qr],a[i])) qr--;
while(qr>ql&&ck(L[ql+1],L[ql],a[i])) ql++;
L[++qr]=a[i];
}
while(qr>ql&&ck(L[qr-1],L[qr],L[ql])) qr--;
while(qr>ql&&ck(L[ql+1],L[ql],L[qr])) ql++;
L[qr+1]=L[ql];
for(int i=ql;i<=qr;i++)
p[++cnt]=inter(L[i],L[i+1]);
return get_Area(cnt);
}
int main() {
#ifdef DEBUG
freopen(".in","r",stdin);
freopen(".out","w",stdout);
#endif
read(n);
for(int i=1;i<=n;i++) {
read(p[i].x); read(p[i].y);
}
p[n+1]=p[1]; ans=get_Area(n);
for(int i=1;i<=n;i++) {
L[++cnt].a=p[i]; L[cnt].b=p[i+1];
L[cnt].slop=atan2(L[cnt].b.y-L[cnt].a.y,L[cnt].b.x-L[cnt].a.x);
}
T0=p[1]; T1=p[2];
for(int i=1;i<=n;i++) {
T2=p[i]; T3=p[i+1];
db a=T0.y-T1.y-T2.y+T3.y;
db b=T1.x-T0.x-T3.x+T2.x;
db c=cross(T2,T3)-cross(T0,T1);
db xx,yy;
if(a==0&&b==0) continue;
if(b==0) { xx=c/a; yy=1;}
else if(a==0) { xx=1; yy=c/b; }
else xx=1,yy=(c-a*xx)/b;
L[++cnt].a=pt(xx,yy);
if(b==0) { xx=c/a; yy=2;}
else if(a==0) { xx=2; yy=c/b; }
else xx=2,yy=(c-a*xx)/b;
L[cnt].b=pt(xx,yy);
if(b==0) xx=xx+100;
else if(a==0) yy=yy+100;
else yy=yy+100;
pt tp=pt(xx,yy);
if(a*xx+b*yy-c<0) {
if(cross(L[cnt].b-L[cnt].a,tp-L[cnt].a)<0) swap(L[cnt].a,L[cnt].b);
}
else {
if(cross(L[cnt].b-L[cnt].a,tp-L[cnt].a)>0) swap(L[cnt].a,L[cnt].b);
}
L[cnt].slop=atan2(L[cnt].b.y-L[cnt].a.y,L[cnt].b.x-L[cnt].a.x);
}
ans=solve(cnt)/ans;
printf("%.4lf\n",ans);
return 0;
}
/*
5
1 8
0 7
0 0
8 0
8 8
*/
d2t1小凸玩密室
奥妙重重的树形dp
容易想到最基础的dp,dp[i][j]表示点亮了x的整颗子树，最后一个点亮的是j的方案数。
尝试优化这个dp,对于一个有父亲的x来说，要么是先点亮它的父亲再点它，再点它兄弟，要么是先点它，再点它父亲，再点它兄弟（它兄弟先的两种情况对称）。
也就是要么它要对他父亲负责，要么它要对他父亲的另一个儿子负责。
那么对于每一个叶子节点，要么它要对它的某个祖先负责，要么它要对某个祖先的儿子负责。
g[x][i]表示点亮x后点亮x的第i个祖先需要的最小代价，f[x][i]表示点亮x后点亮x的第i个祖先的另一个儿子的最小代价。
就可以直接转移了 (b表示到父亲的边的权值)
g[x][i]=min(b[lc]*v[lc]+f[lc][0]+g[rc][i+1],b[rc]*v[rc]+f[rc][0]+g[lc][i+1]);
f[x][i]=min(b[lc]*v[lc]+f[lc][0]+f[rc][i+1],b[rc]*v[rc]+f[rc][0]+f[lc][i+1]);
然后再枚举从每个点开始点统计答案即可。
//Achen
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<queue>
#include<cmath>
#define For(i,a,b) for(int i=(a);i<=(b);i++)
#define Rep(i,a,b) for(int i=(a);i>=(b);i--)
const int N=2e5+7;
typedef long long LL;
typedef double db;
using namespace std;
int n;
LL v[N],f[N][19],g[N][19],R[N],ans,b[N];
//f[x][i] 点亮子树x之后点了x的第i个父亲的儿子
//g[x][i] 点亮子树x之后点了x的第i个父亲
template<typename T>void read(T &x) {
char ch=getchar(); x=0; T f=1;
while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
if(ch=='-') f=-1,ch=getchar();
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0'; x*=f;
}
#define lc x<<1
#define rc (x<<1|1)
void dfs(int x) {
R[x]=R[x/2]+b[x];
if(lc>n) {
int fa=x/2,pr=x;
For(i,0,18) {
int son=(pr&1)?(fa<<1):(fa<<1|1);
g[x][i]=(R[x]-R[fa])*v[fa];
f[x][i]=(R[x]-R[fa]+b[son])*v[son];
pr=fa; fa/=2;
}
return;
}
dfs(lc); dfs(rc);
For(i,0,18) {
if(rc>n) {
g[x][i]=b[lc]*v[lc]+g[lc][i+1];
f[x][i]=b[lc]*v[lc]+f[lc][i+1];
}
else {
g[x][i]=min(b[lc]*v[lc]+f[lc][0]+g[rc][i+1],b[rc]*v[rc]+f[rc][0]+g[lc][i+1]);
f[x][i]=min(b[lc]*v[lc]+f[lc][0]+f[rc][i+1],b[rc]*v[rc]+f[rc][0]+f[lc][i+1]);
}
}
}
void calc(int x) {
LL tp=g[x][0];
int fa=x/2,pr=x;
for(;fa;) {
int son=(pr&1)?(fa<<1):(fa<<1|1);
tp+=b[son]*v[son]+g[son][1];
pr=fa; fa/=2;
}
ans=min(ans,tp);
if(lc>n) return;
calc(lc); calc(rc);
}
int main() {
#ifdef DEBUG
freopen(".in","r",stdin);
freopen(".out","w",stdout);
#endif
memset(g,127/3,sizeof(g));
memset(f,127/3,sizeof(f));
ans=g[0][0];
read(n);
For(i,1,n) read(v[i]);
For(i,2,n) read(b[i]);
dfs(1);
calc(1);
printf("%lld\n",ans);
return 0;
}
d2t2
没写，就口胡一下。
用一个set存每一段0的区间，每次从一个点开始先暴力修改这个点的值，修改我的set，查完后改回来。
查询的时候就看现在查的在哪个位置，可以把整段区间分成左右两半，小的一半直接找begin或者rbegin即可，大的一半lower_bound ( i+n/2 ) 用左右两个区间更新答案。
需要注意找到的区间若包涵当前查询位置更新的答案为0，还要特判最前最后区间连一起的情况。
d2t3 情报传递
第一问直接查询lca即可。
第二问，相当于给每个点赋值，询问路径上小于某个值的点的个数。
把赋值操作离线下来排序，查询也离线下来排序，树链剖分即可。
如果你闲的淡疼，也可以写个啥子主席树之类的。
