The 1st Universal CupStage 15: Hangzhou ACH

我写的里面，最有意思的是H了，C是最无聊最傻逼纯体力活的

A 二分交互题，只需要保证左边永远大于右边的值就行了

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int N=1e6+10;

int query(int x)
{
    printf("? %d\n",x);fflush(stdout);scanf("%d",&x);return x;
}
void print(int x)
{
    printf("! %d\n",x);
    fflush(stdout);
}
void solve()
{
    int n;scanf("%d",&n);
    int lst=0;
    int l=1,r=n;
    while(1)
    {
        int now=query(l);
        if(now==lst){print(l);return ;}
        l=l+1;
        lst=now;
        while(l<r)
        {
            int mid=l+r>>1;
            int now=query(mid);
            if(now==lst){print(mid);return ;}
            if(now>lst)
            {
                l=mid+1;lst=now;
            }
            else
            {
                r=mid-1;lst=now;break;
            }
        }
        if(l==r){print(l);return ;}
    }
}
int main()
{
    int T=1;
    while(T--)solve();
}

 C 发现最多只能从u节点往上爬一个，并且u节点的子树里所有未匹配点，最多只能有一个不在u节点匹配，所以就随便贪心了

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
vector<int>e[N];
int tp[N],dep[N];
char op[10];
int func()
{
    if(op[0]=='T')return 1;
    else if(op[0]=='C')return 2;
    else if(op[0]=='D')return 3;
    return 0;
}
bool fg;
vector<array<int,2>>rs;
vector<int> get2(vector<int>&v1,vector<int>&v2)
{
    vector<int>vec;
    priority_queue<array<int,2>>h1,h2;
    for(auto x:v1)h1.push({dep[x],x});
    for(auto x:v2)h2.push({dep[x],x});
    while(h1.size())
    {
        if(h2.empty())break;
        auto [d1,a]=h1.top();
        auto [d2,b]=h2.top();
        if(d1>d2)
        {
            h1.pop();h2.pop();rs.push_back({a,b});
        }
        else 
        {
            h2.pop();vec.push_back(b);
        }
    }
    while(h1.size())vec.push_back(h1.top()[1]),h1.pop();
    while(h2.size())vec.push_back(h2.top()[1]),h2.pop();
    return vec;
}
vector<int> get1(vector<int>&v1,vector<int>&v2)
{
    vector<int>vec;
    priority_queue<array<int,2>,vector<array<int,2>>,greater<array<int,2>>>h1,h2;
    for(auto x:v1)h1.push({dep[x],x});
    for(auto x:v2)h2.push({dep[x],x});
    while(h1.size())
    {
        if(h2.empty())break;
        auto [d1,a]=h1.top();
        auto [d2,b]=h2.top();
        if(d1>d2)
        {
            h1.pop();h2.pop();rs.push_back({a,b});
        }
        else 
        {
            h1.pop();vec.push_back(a);
        }
    }
    while(h1.size())vec.push_back(h1.top()[1]),h1.pop();
    while(h2.size())vec.push_back(h2.top()[1]),h2.pop();
    return vec;
}
int dfs(int u)
{
    vector<int>v[3],vec;
    if(tp[u])v[tp[u]-1].push_back(u);
    for(auto x:e[u])
    {
        dep[x]=dep[u]+1;
        int now=dfs(x);
        if(now)v[tp[now]-1].push_back(now);
    }
    for(int i=0;i<3;++i)
    sort(v[i].begin(),v[i].end(),[&](const int a,const int b){return dep[a]<dep[b];});
    
    
    vector<int>f;
    priority_queue<array<int,2>>heap;
    for(auto x:v[0])heap.push({dep[x],x});
    while(heap.size())
    {
        auto [d1,a]=heap.top();heap.pop();
        if(heap.empty()){f.push_back(a);break;}
        auto [d2,b]=heap.top();
        if(d1==d2)rs.push_back({a,b}),heap.pop();
        else f.push_back(a);
    }
    if(abs((int)v[1].size()-(int)v[2].size())>1){printf("NO\n");exit(0);}
    
    if(v[1].size()>=v[2].size())vec=get1(v[1],v[2]);
    else vec=get2(v[1],v[2]);
    
    if(f.size()&&vec.size()){printf("NO\n");exit(0);}
    else if(vec.size()>1){printf("NO\n");exit(0);}
    if(vec.size())return vec.back();
    if(f.size())return f.back();
    return 0;
}
int main()
{
    int n;scanf("%d",&n);
    for(int i=1,u,fa;i<n;++i)
    scanf("%d%d%s",&u,&fa,op),e[fa].push_back(u),tp[u]=func();
   // for(int i=1;i<=n;++i)cout<<tp[i]<<" ";cout<<endl;
    int t=dfs(1);
    if(t){printf("NO\n");return 0;}
    printf("YES\n");
    //cout<<rs.size()<<endl;
    for(auto [u,v]:rs)cout<<u<<" "<<v<<"\n";
}

H 挺有意思的，发现只有相邻的两点才能诞生斜率最小的点

然后注意到直接求只能n^2，所以二分斜率

然后有式子yi -k*xi >=yj-k*xj 

然后就值域线段树维护这个的最小值，线段树上二分就好了

值域线段树的值域x是指，能找到连续x个满足要求的最后一个的值是min（yj-k*xj）

稍微有点卡精度？可能我不擅长精度问题

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int N=1e5+10;

struct DOT
{
 int x,y;   
}dot[N];
using ld=double;
struct Node
{
    int l,r;ld val;
}tr[N<<2];
const ld inf=1e18;
const ld eps=1e-8;
void pushup(int u)
{
    tr[u].val=min(tr[u<<1].val,tr[u<<1|1].val);
}
void build(int u,int l,int r)
{
    tr[u]={l,r,inf};
    if(l==r)return ;
    int mid=l+r>>1;
    build(u<<1,l,mid);build(u<<1|1,mid+1,r);
}
void modify(int u,int pos,const ld &x)
{
    if(tr[u].l==tr[u].r){tr[u].val=min(tr[u].val,x);return ;}
    int mid=tr[u].l+tr[u].r>>1;
    if(pos<=mid)modify(u<<1,pos,x);
    else modify(u<<1|1,pos,x);
    pushup(u);
}
int query(int u,const ld &x)
{
    if(tr[u].val>x+eps)return 0;
    if(tr[u].l==tr[u].r)return tr[u].l;
    if(tr[u<<1|1].val<=x+eps)return query(u<<1|1,x);
    return query(u<<1,x);
}
bool check(ld k,int n,int cnt)
{
    build(1,1,n);
    int mx=1;
    for(int i=1;i<=n;++i)
    {
        ld now=dot[i].y-k*dot[i].x;
        int val=query(1,now)+1;
        modify(1,val,now);
        mx=max(mx,val);
    }
   // cout<<mx<<endl;
    return mx>=cnt;
}
void solve()
{
    int n,k;scanf("%d%d",&n,&k);//k=n-k;
    for(int i=1,x,y;i<=n;++i)scanf("%d%d",&x,&y),dot[i]={x,y};
    ld l=-1e9+10,r=1e9+10;
    int cnt=60;
  //  check(10000.0,n,k);
    while(cnt--&&(abs(l-r)>=eps))
    {
        ld mid=(l+r)/2;
        if(check(mid,n,k))l=mid;
        else r=mid;
    }
    printf("%.6lf\n",r);
}
int main()
{
    int T=1;
    while(T--)solve();
}