Codeforces Round #693 (Div. 3)

传送门
E ：
首先维护hi>=wi(小于也没问题），然后h作为第一关键字递增排序。
然后遍历这个数组，维护一个最小的w的位置，还要保证该位置的h严格小于当前点的h，双指针扫一遍即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1000100;
typedef pair<int,int> pii;
#define fi first
#define se second
int t,n,m;
int nums[N],len;
int ans[N];
int find(int x)
{
	return lower_bound(nums+1,nums+len+1,x)-nums;
}
struct node
{
	int l,r,id;
	bool operator < (const node &w) const{
		return l<w.l;
	}
}e[N];
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;++i)
		{
			int l,r;
			scanf("%d%d",&l,&r);
			if(l<r) swap(l,r);
			e[i]={l,r,i};
		}
		sort(e+1,e+n+1);
		int res=1e9+7,pos=0;
		for(int i=1,j=1;i<=n;++i)
		{
			while(e[i].l>e[j].l)
			{
				if(res>e[j].r)
				{
					res=e[j].r;
					pos=e[j].id;
				}
				j++;
			}
			if(e[i].r<=res) ans[e[i].id]=-1;
			else ans[e[i].id]=pos;
		}
		for(int i=1;i<=n;++i) printf("%d ",ans[i]);
		puts("");
	}
	return 0;
}

F 题目很像一道状压dp的模板题（传送门），所以往状压的方向考虑。数轴太大了得离散化一下，离散化之后还得保证任意两点之间的奇偶性不变，就是说两个点之间原本有偶数个点，离散化之后还得是偶数个点才不影响答案的正确性。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1000100;
typedef pair<int,int> pii;
#define fi first
#define se second
int t,n,m;
int nums[N],len;
int x[N],y[N],a[N];
bool f[N][4],st[N][2];
int find(int x)
{
	return lower_bound(nums+1,nums+len+1,x)-nums;
}
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&m);
		len=0;
		for(int i=1;i<=m;++i)
		{	
			scanf("%d%d",x+i,y+i);
			nums[++len]=y[i];
			x[i]--;
		}
		sort(nums+1,nums+len+1);
		len=unique(nums+1,nums+len+1)-(nums+1);
		int sz=len;
		for(int i=2;i<=sz;++i)
		{
			if((nums[i]-nums[i-1])%2==0)
				nums[++len]=nums[i]-1;
			else if(nums[i]-nums[i-1]>=2)
			{
				nums[++len]=nums[i]-1;
				nums[++len]=nums[i]-2;
			}
		}
		sort(nums+1,nums+len+1);
		for(int i=1;i<=m;++i) y[i]=find(y[i]);
		for(int i=1;i<=len+1;++i)
			for(int j=0;j<4;++j)
			{
				f[i][j]=0;
				if(j<2) st[i][j]=0;
			}
		for(int i=1;i<=m;++i) st[y[i]][x[i]]=1;
		for(int i=1;i<=len;++i)
		{
			a[i]=0;
			for(int j=0;j<2;++j)
				a[i]|=(st[i][j]<<j);//处理每一列障碍物的状态
		}
		f[1][0]=1;
		for(int i=1;i<=len;++i)
		{
			if(f[i][0])
			{
				if(!a[i]) f[i+1][0]=f[i+1][3]=1;
				else  f[i+1][3^a[i]]=1;	
			}
			for(int j=1;j<4;++j)
				if(f[i][j])
				{
					if(a[i]&j) continue;//状态有冲突
					if(!a[i]) f[i+1][3^j]=1;
					else f[i+1][0]=1;
				}
		}
		printf(f[len+1][0]?"YES\n":"NO\n");
	}
	return 0;
}

F d数组就是从1点出发的最短路。然后小明的旅行方式有三种：
（1）向d值更高的点走
（2）向d值大于等于当前点的点走
（3）停止
限制条件是（2）最多只有一次。
先跑一遍迪杰斯特拉处理出来d数组。然后考虑怎么搜答案。假设u到v有条边，
如果$d_u$大于等于$d_v$，那么从u到v就用一次方式（2），之后从v点只能向大于$d_v$的点走，所以直接返回$d_v$即可。
如果$d_u$小于$d_v$，直接搜即可。当然还要加记忆化。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=200100;
typedef pair<int,int> pii;
#define fi first
#define se second
int t,n,m;
int h[N],e[N],ne[N],idx;
void add(int a,int b)
{
	e[idx]=b;ne[idx]=h[a];h[a]=idx++;
}
int d[N];
bool st[N];
void dij()
{
	priority_queue<pii,vector<pii>,greater<pii> > q;
	for(int i=1;i<=n;++i) d[i]=1e8,st[i]=0;
	d[1]=0;
	q.push({0,1});
	while(q.size())
	{
		int u=q.top().se;
		q.pop();
		if(st[u]) continue;
		st[u]=1;
		for(int i=h[u];~i;i=ne[i])
		{
			int v=e[i];
			if(d[v]>d[u]+1)
			{
				d[v]=d[u]+1;
				q.push({d[v],v});
			}
		}
	}
}
int dis[N];
void dfs(int u)
{
	if(st[u]) return ;
	st[u]=1;
	for(int i=h[u];~i;i=ne[i])
	{
		int v=e[i];
		if(d[v]>d[u])
		{
			dfs(v);
			dis[u]=min(dis[u],dis[v]);
		}
		else{
			dis[u]=min(dis[u],d[v]);
		}
	}
}
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&m);
		for(int i=0;i<=n;++i) h[i]=-1;
		idx=0;
		while(m--)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			add(u,v);
		}
		dij();
		for(int i=1;i<=n;++i) st[i]=0,dis[i]=d[i];
		for(int i=1;i<=n;++i)
			if(!st[i]) dfs(i);
		for(int i=1;i<=n;++i) printf("%d ",dis[i]);
		puts("");
	}
	return 0;
}