Problem A: Maze
Time Limit: 1000 ms Memory Limit: 256 MB
Description
考虑一个N×M的网格，每个网格要么是空的，要么是障碍物。整个网格四周都是墙壁（即第1行和第n行，第1列和第m列都是墙壁），墙壁有且仅有两处开口，分别代表起点和终点。起点总是在网格左边，终点总是在网格右边。你只能朝4个方向移动：上下左右。数据保证从起点到终点至少有一条路径。
从起点到终点可能有很多条路径，请找出有多少个网格是所有路径的必经网格。
Input
第一行包含两个整数 N,M，表示网格 N 行 M列。
接下来 N行，每行 M个字符，表示网格。'#'表示障碍物或墙壁，'.'表示空地。
Output
输出文件包含一个整数，必经点的个数。
Sample Input
7 7
#######
....#.#
#.#.###
#.....#
###.#.#
#.#....
#######
Sample Output
5HINT
样例解释
(2, 1) (2, 2) (4, 4) (6, 6) (6, 7)
数据范围与约定
对于10%的数据， 3≤N,M≤50
对于50%的数据， 3≤N,M≤500
对于所有数据， 3≤N,M≤1000
Solution
先建个图，然后tarjan割点
割点的时候判断这个点在不在起点到终点的路上，如果不在就没必要算入答案。
#include
using namespace std;
struct qwq{
int v;
int nxt;
}edge[4000001];
int head[1000001];
int cnt=-1;
void add(int u,int v){
edge[++cnt].nxt=head[u];
edge[cnt].v=v;
head[u]=cnt;
}
int dfn[1000001];
int low[1000001];
int rt;
int ind;
int s,t;
bool pd[1000001];
bool tarjan(int u){
dfn[u]=low[u]=++ind;
int child=0;
bool flag=false;
for(int i=head[u];~i;i=edge[i].nxt){
int v=edge[i].v;
bool fflag=false;
if(!dfn[v]){
fflag=tarjan(v);
flag=flag||fflag;
low[u]=min(low[u],low[v]);
if(dfn[u]<=low[v]&&fflag){
pd[u]=true;
}
}
low[u]=min(low[u],dfn[v]);
}
return flag||u==t;
}
bool mapn[1001][1001];
int movex[4]={0,1,0,-1};
int movey[4]={1,0,-1,0};
int main(){
memset(head,-1,sizeof(head));
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
char ch;
cin>>ch;
if(ch=='.'){
mapn[i][j]=true;
if(j==1){
s=(i-1)*n+j;
}
if(j==n){
t=(i-1)*n+j;
}
}
}
}
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
if(!mapn[i][j])continue;
for(int k=0;k<4;++k){
int x=i+movex[k],y=j+movey[k];
if(x<1||y<1||x>n||y>m||!mapn[x][y])continue;
add((i-1)*n+j,(x-1)*n+y);
}
}
}
//cout< Problem B: 懒人跑步
Time Limit: 1000 ms Memory Limit: 256 MB
Description
在ZJU，每个学生都被要求课外跑步，并且需要跑够一定的距离 K，否则体育课会挂科。
ZJU有4个打卡点，分别标记为 p1,p2,p3,p4。每次你到达一个打卡点，你只需要刷一下卡，系统会自动计算这个打卡点和上一个打卡点的距离，并将它计入你的已跑距离。
系统把这4个打卡点看成一个环。 p1与 p2 相邻、 p2 与 p3 相邻、 p3 与 p4 相邻、 p4 与 p1 相邻。当你到达打卡点 pi时，你只能跑到与该打卡点相邻的打卡点打卡。
打卡点 p2是离宿舍最近的一个打卡点。CJB总是从 p2 出发，并回到 p2 。因为CJB很圆，所以他希望他跑的距离不少于 K，但又要尽量小。
Input
第一行为一个整数 T，表示数据组数。
对于每组数据，有5个正整数 K,d1,2,d2,3,d3,4,d4,1(1≤K≤10^18,1≤d≤30000)，表示至少要跑的距离和每两个相邻的打卡点的距离。
Output
对于每组数据，输出一个整数表示CJB最少需要跑多少距离。
Sample Input
1
2000 600 650 535 380
Sample Output
2165HINT
样例解释
最优路径为 2−1−4−3−2
数据范围与约定
对于30%的数据， 1≤K≤30000,1≤d≤30000
对于100%的数据， 1≤K≤10^18,1≤d≤30000,1≤T≤10
Solution
首先我们显然可以在任意一条道路上来回摩擦
那么假设我们有一条长度为K的路径，设w=min(dis(1,2),dis(2,3))，肯定有一条长度为k+2w的路径
所以我们设dis[i][j]为到达某一个点，且dis[i][j]≡j(mod 2w)的最短距离
然后用类似最短路的方式更新，最后到达2号点的mod 2w的值最小的路径的就好了
#include
using namespace std;
#define ll long long
struct data{
int p;
int m;
};
int d[4];
ll dis[4][100001];
bool vis[4][100001];
void spfa(int w){
memset(dis,0x7f,sizeof(dis));
//memset(vis,0,sizeof(vis));
queue q;
q.push(data{1,0});
dis[1][0]=0;
vis[1][0]=true;
while(!q.empty()){
int p=q.front().p,m=q.front().m;
int nxt=(p+1)%4,pre=(p+3)%4;
//cout<k)k++;
printf("%lld\n",k);
}
} Problem C: 道路建设
Time Limit: 4000 ms Memory Limit: 512 MB
Sample Input
5 7
1 2 2
2 3 4
3 4 3
4 5 1
5 1 3
2 5 4
1 4 5
5
1 2
4 7
11 12
11 13
18 19
Sample Output
3
9
8
14
13HINT
样例解释
解密后的询问为 (1,2),(1,4),(2,3),(3,5),(4,5)
修建道路最小费用的方案为 {(1,2),(4,5)},{(2,1),(1,5),(5,4),(4,3)},{(1,2),(1,5),(3,4)},{(1,5),(5,2),(2,3),(3,4)},{(3,2),(2,5),(1,4)}
数据规模与约定
子任务1（5分）： 1≤n,m,q≤1000,online=1
子任务2（11分）： 1≤n≤1000,1≤m,q≤10^5,online=0
子任务3（14分）： 1≤n≤1000,1≤m,q≤10^5,online=1
子任务4（21分）： 1≤n,m,q≤10^5,online=0
子任务5（49分）： 1≤n,m,q≤10^5,online=1
Solution
首先如果此题没有强制在线，我们可以用LCT模拟建立最小生成树的过程。
首先把边权从大到小排序，不断把边插入LCT中，
如果当前加入的边与原来的边构成了一个环，我们找到这个环上最大的边去掉，然后加入这条边。
现在我们要让他能够在线处理，那我们就建立一棵主席树来方便查询历史版本。
然后每次查询l,r只需要查询版本为l且小于等于r的边的和就可以了（因为在这个版本中比l小的还未加入进来）
有史以来写过的最恶心的题
#include
using namespace std;
struct node{
int ch[2];
int fa;
int val;
int tag;
int mp;
}t[300001];
bool nroot(int x){
return t[t[x].fa].ch[0]==x||t[t[x].fa].ch[1]==x;
}
void pushup(int x){
t[x].mp=x;
int lc=t[x].ch[0],rc=t[x].ch[1];
if(t[t[lc].mp].val>t[t[x].mp].val)t[x].mp=t[lc].mp;
if(t[t[rc].mp].val>t[t[x].mp].val)t[x].mp=t[rc].mp;
}
void rev(int x){
swap(t[x].ch[0],t[x].ch[1]);
t[x].tag^=1;
}
void pushdown(int x){
if(t[x].tag){
if(t[x].ch[0])rev(t[x].ch[0]);
if(t[x].ch[1])rev(t[x].ch[1]);
t[x].tag=0;
}
}
void rotate(int x){
int fa=t[x].fa;
int gfa=t[fa].fa;
bool k=t[fa].ch[1]==x;
if(nroot(fa))t[gfa].ch[t[gfa].ch[1]==fa]=x;
t[x].fa=gfa;
t[fa].ch[k]=t[x].ch[k^1];
if(t[x].ch[k^1])t[t[x].ch[k^1]].fa=fa;
t[fa].fa=x;
t[x].ch[k^1]=fa;
pushup(fa);pushup(x);
}
int st[2000001];
void splay(int x){
int y=x,z=0;
st[++z]=y;
while(nroot(y)){
st[++z]=y=t[y].fa;
}
while(z)pushdown(st[z--]);
while(nroot(x)){
int fa=t[x].fa;
int gfa=t[fa].fa;
if(nroot(fa)){
if((t[fa].ch[1]==x)^(t[gfa].ch[1]==fa))rotate(x);
else rotate(fa);
}
rotate(x);
}
pushup(x);
}
void access(int x){
int y=0;
while(x){
//cout<b.w;
}
int fa[100001];
int findfa(int x){
return fa[x]==x?x:fa[x]=findfa(fa[x]);
}
struct seg{
int l,r,val;
}tt[4000001];
int rt[10001];
int cnt;
void update(int now,int &root,int p,int v,int l,int r){
root=++cnt;
tt[root]=tt[now];
tt[root].val+=v;
if(l==r)return;
int mid=(l+r)/2;
if(p<=mid)update(tt[now].l,tt[root].l,p,v,l,mid);
else update(tt[now].r,tt[root].r,p,v,mid+1,r);
}
int query(int now,int L,int R,int l,int r){
if(now==0)return 0;
if(L<=l&&r<=R)return tt[now].val;
int mid=(l+r)/2;
int ret=0;
if(L<=mid)ret+=query(tt[now].l,L,R,l,mid);
if(mid=2;i--){
if(!rt[i-1]){
rt[i-1]=rt[i];
}
}
int q,last=0;
scanf("%d",&q);
while(q--){
int l,r;
scanf("%d%d",&l,&r);
l-=last*online;
r-=last*online;
printf("%d\n",last=query(rt[l],1,r,1,N));
}
}