传送门
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_u
du大于等于
d
v
d_v
dv,那么从u到v就用一次方式(2),之后从v点只能向大于
d
v
d_v
dv的点走,所以直接返回
d
v
d_v
dv即可。
如果
d
u
d_u
du小于
d
v
d_v
dv,直接搜即可。当然还要加记忆化。
#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;
}