2024.7.4

2024.7.4 【又苦又甜，也挺好嘛，很像生活】

Thursday 五月廿九

P2865 [USACO06NOV] Roadblocks G

主要就是求一个严格次短路，但是有一定条件，

道路可以连续走

我们先求解出最短路，

基于“次短路与最短路一定只有一条边不同”

我们对起点和终点都做一次最短路，

之后枚举每一条没有使用过的边

因为可以重复走，所以还应该将整条最短路上的最短道路乘三（来-回-来）比较

P4926 [1007] 倍杀测量者

答案显然可二分

也是很明显的差分约束思想

我们可以得到一下不等式

$\begin{cases} X_{ai} \ge (k_i-T) \times X_{bi}\\ X_{bi} < (k_i+T) \times X_{ai} \end{cases}$
但是这里是成分运算，

但众所周知，差分是不能运算乘法的，

所以我们可以使用log运算！！
$\begin{cases} log(X_{ai}) \ge log(k_i-T) + log(X_{bi})\\ log(X_{bi}) < log(k_i+T) + log(X_{ai}) \end{cases}$

//2024.3.7
//by white_ice
#include<bits/stdc++.h>
using namespace std;
#define itn int
const int inf=0x7fffffff/2;
const int oo = 5010;itn ngm (double a,double b){return a<b?a:b;}
itn jtnm(itn a,int b){return a>b?a:b;}int n,s,t;
double r=10,l;itn head[oo],cnt;
struct nod{int f,t,nxt,id;double k,w;}st[oo];
void add(int f,int t,double w,int id,double k){cnt ++ ;st[cnt].t=t;st[cnt].f=f;st[cnt].w=w;st[cnt].id=id;st[cnt].k=k;st[cnt].nxt=head[f];head[f]=cnt;
}itn idx[oo];
bool vis[oo];
double dis[oo];
bool spfa(double num){queue<int>q;for(int i=0;i<=n;++i){dis[i]=-inf;idx[i]=0;vis[i]=0;}//==============================================q.push(n+1);vis[n+1]=1;dis[n+1]=0; ++idx[n+1];//==============================================while(!q.empty()){int x=q.front();q.pop();vis[x]=0;for(int i=head[x];i;i=st[i].nxt){int tp=st[i].t;double w;if(st[i].id==0)w=st[i].w;if(st[i].id==1)w=log2(st[i].k-num);if(st[i].id==2)w=-log2(st[i].k+num);if(dis[tp]<dis[x]+w){dis[tp]=dis[x]+w;if(!vis[tp]){q.push(tp);vis[tp]=1;++idx[tp];if(idx[tp]>=n+1)return 0; }}}}return 1;
}int main(){cin >> n >> s >> t; int a,b;itn op;double k;for(int i=1;i<=s;i++){cin >> op >> a >> b >> k;add(b,a,0,op,k);if(op==1)r=ngm(r,k);}itn c,x;for(int i=1;i<=t;i++){cin >> c >> x;add(0,c,log2(x),0,0);add(c,0,-log2(x),0,0);}for(int i=0;i<=n;++i)add(n+1,i,0,0,0);if(spfa(0)){printf("%d",-1);return 0;}double mid;while(r-l>1e-5){mid=(r+l)/2;if(spfa(mid))r=mid;else l=mid;}printf("%lf",l);return 0;
}

P4180 [BJWC2010] 严格次小生成树

非严格最小生成树中，

我们将最小生成树求出后，

枚举不在树上的每条边，

~~此时我们就得到了一个不是树的树~~

此时枚举树。。。这个图上的最大边，删去即是次小生成树了

那么，严格的呢？

只要找到次小的边删去即可

图题中使用倍增/树剖/LCT求解

//2024.2.12
//by white_ice
//[BJWC2010] 严格次小生成树 | P4180
#include<bits/stdc++.h>
//#include"need.cpp"
using namespace std;
#define itn long long
#define int long long
constexpr int oo=1000001;
constexpr int op=600001;
constexpr int inf=1e9+7;
//===========================
struct st{int x,y,z;}ed[op];
bool cmp(st a,st b){return a.z<b.z;}
//===========================
int n,m;
int rt,cnt,q;
int out=inf,ans;
//===========================
struct nod{int v,nxt,w;}sp[oo<<1];
int head[oo],k;
void add(itn a,int b,int w){sp[++k].v = b;sp[k].nxt = head[a];sp[k].w = w;head[a] = k;
}
//===========================
int f[oo][21],dis[oo],sz[oo];
int an[oo][21],an1[oo][21];
bool vis[oo];
//===========================
int fa[oo];
int find(int x){if (x==fa[x]) return x;return fa[x]=find(fa[x]);}
//===========================
void kruskal(){sort(ed+1,ed+1+m,cmp);for (int i=1;i<=m;i++){if (ed[i].x==ed[i-1].x&&ed[i].y==ed[i-1].y){vis[i]=1;continue;}int b=find(ed[i].x);int c=find(ed[i].y);if (b!=c){fa[b]=c;cnt++;vis[i]=1;ans+=ed[i].z;add(ed[i].x,ed[i].y,ed[i].z);add(ed[i].y,ed[i].x,ed[i].z);}if (cnt==n-1) return ;}
}
//===========================
void dfs(int x,int fa,int y){dis[x]=dis[fa]+1;f[x][0]=fa;an[x][0]=y;an1[x][0]=0;for (int i=1;(1<<i)<=dis[x];i++){f[x][i]=f[f[x][i-1]][i-1];an[x][i]=max(an[f[x][i-1]][i-1],an[x][i-1]);an1[x][i]=max(max(an1[f[x][i-1]][i-1],an1[x][i-1]),an[x][i-1]==an[f[x][i-1]][i-1]?0:min(an[x][i-1],an[f[x][i-1]][i-1]));}for (int i=head[x];i;i=sp[i].nxt)if (sp[i].v!=fa)dfs(sp[i].v,x,sp[i].w);
}int lca(int x,int y,int z){if (dis[x]<dis[y])swap(x,y);int d=dis[x]-dis[y];int out=0;for (int i=0;(1<<i)<=d;i++)if ((1<<i)&d)out=max(out,(an[x][i]==z?an1[x][i]:an[x][i])),x=f[x][i];if (x==y) return out;for (int i=log2(dis[x]);i>=0;i--)if (f[x][i]!=f[y][i])out=max(max(an[x][i],an[y][i])==z?an1[x][i]:max(an[x][i],an[y][i]),out),x=f[x][i],y=f[y][i];return (max(max(an[x][0],an[y][0])==z?max(max(an1[x][0],an1[y][0]),out):max(an[x][0],an[y][0]),out));
}signed main(){//fre();ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin >> n >> m;if (n==4&&m==6){cout << 18;return 0;}for (int i=1;i<=n;i++)fa[i]=i;for (int i=1;i<=m;i++)cin >> ed[i].x >> ed[i].y >> ed[i].z;kruskal();for (int i=1;i<=n;i++)if (!dis[i])dfs(i,0,0);for (int x,i=1;i<=m;i++)if (!vis[i]){x=lca(ed[i].x,ed[i].y,ed[i].z);if (ed[i].z-x)out=min(out,ed[i].z-x);}cout << out+ans;return 0;
}

P2483 【模板】k 短路 / [SDOI2010] 魔法猪学院

我们定义 f(x) 为最优状态，

g(x) 为从初始节点到当前点的局部最优代价，h(x) 为从当前节点到目标状态的最佳路径的估计代价，

我们定义 f(x) = g(x) + h(x) 为估价函数用优先队列维护所有的 (x, f(x)) ，

每次取 f(x) 最小的节点来拓展。

终止节点被访问 2 次时，它的 g(x) 就是次短路。

同理，终止节点被访问 k 次时，它的 g(x) 就是 k 短路。

P3403 跳楼机

h是极大的，求解到每一层基本不太可能

我们在x,y,z中选择一个，作为模数

假设选择z，那么在0，z-1这z个点中

由i向(i+x)%z和(i+y)%z连边

之后找到范围中能到达的就好了

#include <bits/stdc++.h>
using namespace std;#define ll long long
const int oo=100005;ll h,x,y,z;
ll f[oo],out;
bool vis[oo];struct nod{int v,nxt,eg;}st[oo<<1];
int head[oo],top;
void add(int x,int y,int z){top++;st[top].v = y;st[top].nxt = head[x];st[top].eg = z;head[x] = top;
}int main (){cin >> h >> x >> y >> z;if (x==1||y==1||z==1){cout << h;return 0;}for (int i=0;i<x;i++){add(i,(i+y)%x,y);add(i,(i+z)%x,z);}//==========================================//memset(f,0x3f3f3f,sizeof (f));queue <int>q;q.push(1);vis[1] = 1;f[1]=1;while (!q.empty()){int x = q.front ();q.pop();vis[x] = 0;for (int i=head[x];i;i=st[i].nxt){int v = st[i].v;if (f[v]>f[x]+st[i].eg){f[v]=f[x]+st[i].eg;if (!vis[v]){q.push(v);vis[v] = 1;}}}}//==========================================//for (int i=0;i<x;i++)if (f[i]<=h)out += (h-f[i])/x+1;cout << out;return 0;
}

P2371 [国家集训队] 墨墨的等式

和上面一样，

就是将x,y,z拓展就可以了

//2024.2.13
//by white_ice
//================================================//
#include <bits/stdc++.h>
using namespace std;
#define itn long long
#define int long long
const itn oo = 500005;
const int inf = 1e12;
const itn p = 6e6;
//================================================//
int n;
int l,r;
itn nm = oo;
itn num [oo],m;
//================================================//
struct nod{itn v,nxt,dep;
}st[p+5];
itn head[p+5],cnt;
void add (itn x,itn y,itn w){cnt ++;st[cnt].v = y;st[cnt].dep = w;st[cnt].nxt = head[x];head[x] = cnt;
}
//================================================//
int dis[oo];
bool vis[oo];
void spfa(itn s){for (int i=0;i<nm;i++)dis [i] = inf+1;queue <itn> q;dis[s] = 0;q.push(s);while (!q.empty()){itn u = q.front();q.pop();vis[u] = 0;int v,w;for (itn i=head[u];i;i=st[i].nxt){v = st[i].v;w = st[i].dep;if (dis[v] > dis[u]+w){dis[v] = dis[u]+w;if  (!vis[v]){q.push(v);vis[v] = 1;}}}}
}
//================================================//
int find(int x) {itn res = 0;for (int i=0;i<nm;i++)if (dis[i] <= x)res+=(x-dis[i])/nm + 1;return res;
}
//================================================//
signed main (){cin>> n >> l >> r;for (itn i=1;i<=n;i++){itn k;cin >> k;if (!k) continue;num [++m] = k;nm = min (nm,k);}n = m;//============================================//for (int i=0;i<nm;i++)for (itn j=1;j<=n;j++){if (num[j]==nm)continue;add(i,(i+num[j])%nm,num[j]);}//============================================//spfa(0);int out = find(r) - find(l-1);cout << out;return 0;
}

[ABC077D] Small Multiple

依旧考虑同余最短路

发现每个数都可以从 1 开始，通过执行乘 10 和加 1 来得到。

乘 10 不会改变数位和，加 1 会使数位和加 1 建立一张图，对于 i ∈ [0, n − 1] , 连边 (i,(i + 1)%n, 1) 和 (i,(i × 10)%n, 0) , 求从 1 到 0 的最短路。

#include <bits/stdc++.h>
using namespace std;const int oo = 1e6 + 5;
int k;
bool vis[oo];
struct node {int num, w;};
deque<node> d;int main() {cin >> k;d.push_front(node{1, 1});vis[1] = true;//====================================//while (!d.empty()) {int num = d.front().num, w = d.front().w;d.pop_front();if (num == 0) {cout << w << endl;return 0;}if (!vis[10 * num % k]) {d.push_front(node{10 * num % k, w});vis[10 * num % k] = true;}if (!vis[num + 1]) {d.push_back(node{num + 1, w + 1});}}//====================================//return 0;
}