vis

题目 Description 你是一艘战列巡洋舰的引擎操作人员，这艘船的船员在空间中侦测到了一些无法辨识的异常信号。你的指挥官给你下达了命令，让你制定航线，驾驶战列巡洋舰到达那里。 船上老旧的曲速引擎的速度是0.1AU/s。然而，在太空中分布着许多殖民星域，这些星域可以被看成一个球。在星域的内部，你可以在任何地方任意次跳跃到星域内部的任意一个点，不花费任何时间。 你希望算出到达终点的最短时间。 Input 输入包含多组测试数据。 对于每一组数据，第一行包含一个正整数n，表示殖民星域的数量。 接下来n 行，第i 行包含四个整数Xi，Yi，Zi，Ri，表示第i个星域的中心坐标为(Xi, Yi,Zi)，星域的半径是Ri。 接下来两行，第一行包含值Xa，Ya，Za，告诉你当前坐标为(Xa, Ya,Za)。 第二行包含值Xo，Yo，Zo，告诉你目的地坐标为(Xo, Yo,Zo)。 输入以一行单独的-1 结尾。所有坐标的单位都是天文单位（AU）。 Output 对于每一组输入数据，输出一行表示从目前的位置到达指定目的地的最短时间，取整到最近整数。输入保证取整是明确的。 Sample Input 1 20 20 20 1 0 0 0 0 0 10 1 5 0 0 4 0 0 0 10 0 0 -1 Sample Output 100 20 Data Constraint 每个输入文件至多包含10

【链接】 我是链接,点我呀:) 【题意】 在这里输入题意 【题解】 逆向做一遍bfs. 得到终点到某个点的最短距离。 这样,我们从起点顺序的时候。 就能知道最短路的下一步是要走哪里了。 这样,我们从起点也开始做一遍bfs. 然后根据逆序的bfs得知下一步该往哪些点走。 每次优先走最小的字典序边即可。 多个最小的,就每个都走一遍试试。 6 6 1 2 3 1 3 3 2 4 5 3 5 1 4 6 1 5 6 100 ans = 3->1->100 ↑↑这组数据可以hack网上好多人(>=1)的做法,数据里没有这组。 如果出现前一段路不是最小字典序了,就要结束这一段路了,不能继续往下走。 (或者,这样说,字典序最小的最短路不会到x这个节点来,那么就不能从x再继续往下走了) 【代码】 /* 1.Shoud it use long long ? 2.Have you ever test several sample(at least therr) yourself? 3.Can you promise that the solution is right? At least,the main ideal 4.use the puts("") or putchar() or printf and such things? 5.init the used array or any value

题目： 给一个n个点m条边（2≤m≤100000, 1≤m≤200000）的无向图，每条边上都涂有一种颜色（用1到1000000000表示）。求从结点1到结点n的一条路径， 使得经过的边数尽量少，在此前提下，经过边的颜色序列的字典序最小。一对结点间可能有多条边，一条边可能连接两个相同结点。输入保证结点1可以 到达结点n。 思路： 看到边数尽量少，颜色序列字典序最小，知道这是用BFS来做这个题。但是一直卡在怎么处理颜色的字典序最小上。看了答案之后知道先逆向处理每个节点到终点 的距离d[ i ]，然后在正向分层BFS找出颜色最小的一条路径。 1.逆向处理距离d[]数组。 2.正向分层BFS根据当前结点的d[i]与下一个结点的d[i+1]之间差1来得出颜色字典序最小的一条路径。 这里我一开始使用队列来写的，但是这种写法在一层中找最小的颜色的时候是只找了一个结点，这就导致了得出的答案中的颜色不一定是同一条路径上的。 例如下面这个例子： 6 6 1 2 1 1 3 1 2 4 3 3 5 2 4 6 4 5 6 5 正确的答案应该是1,2,5，而我写出的答案却是1,2,4，苦思无果到网上看了下大佬的博客自己才写出来。 既然是分层BFS那么这种情况我们可以用循环遍历每一层，在每一层中用一个vector数组来存一下这一层中的所有的节点， 在这些节点中查找最小的颜色

题意：给出n个点，m条边，每条边上涂有一个颜色，求从节点1到节点n的最短路径，如果最短路径有多条，要求经过的边上的颜色的字典序最小 紫书的思路：第一次从终点bfs,求出各个节点到终点的最短距离， 第二次bfs从起点沿着每到达一个节点d[]减少1来走，按照颜色的字典序最小的路径来走 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 #include <cmath> 5 #include<stack> 6 #include<vector> 7 #include<map> 8 #include<set> 9 #include<queue> 10 #include<algorithm> 11 using namespace std; 12 13 typedef long long LL; 14 const int INF = 1000000000; 15 const int mod=1000000007; 16 const int maxn=100005; 17 18 struct Edge{ 19 int u,v,c; 20 Edge(int u=0,int v=0,int c=0):u(u),v(v),c(c){} 21 }; 22 23 vector<Edge> edges; 24 vector<int> G

目录 ------------------快速幂 ------------------矩阵快速幂 ------------------dijstrla算法 ------------------spfa算法 ------------------floyd算法 ------------------tarjan算法 ------------------拓扑排序 ------------------树状数组 ------------------线段树+离散化处理 ------------------线段树+dfs序 ------------------线段树+扫描线 ------------------主席树 ------------------树链剖分+线段树 ------------------莫队+dfs序 ------------------st表 ------------------multiset的应用 ------------------kmp算法 ------------------字典树 ------------------manacher算法 ------------------并查集 ------------------快速乘 ------------------单调队列 ------------------三分 快速幂 typedef long long ll;

2019杭电多校第九场 熟悉的后半场挂机节奏，又苟进首页了，很快乐 1001. Rikka with Quicksort upsolved 不是我做的,1e9调和级数分段打表 1002. Rikka with Cake solved at 01:11 有一个矩形，给你很多射线（射线只有横平竖直的四个方向），问把矩形切成了多少块 队友说答案是交点数加一，作为一个合格的工具人，当然是把队友的想法实现啦 二维坐标离散化枚举纵坐标维护横坐标，常规套路，树状数组也可以做（我是线段树写习惯了根本没想起来还有树状数组） #include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; struct P { int x, y; char op[3]; }a[N]; long long ans; int b[N], totx, toty; int T, n, m, K; vector<int> in[N], out[N], le[N], ri[N]; int sum[N << 2]; void pushup(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; } void build(int rt, int l, int r) { if(l == r) { sum[rt]

传送门problem_link 这道就是DFS的入门题。没啥好说的 唯一要注意的可能就是输出格式吧，记得有空行 #include<cstdio> #include <cstring> using namespace std; int n,cnt = 0; int vis[21],A[21]; //一般使用全局变量 //dfs通过全局变量来控制子函数 //素数表,加快后续判断 int prime[38] = {0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1}; void dfs(int step) { int r = 0; if(step == n && prime[A[0]+A[n-1]]) { printf("%d", A[0]); for(int i = 1; i < n; ++i) printf(" %d", A[i]); printf("\n"); } else { for(int i = 2; i <= n; i++) { if(vis[i] == 0 && prime[A[step-1] + i]) { vis[i] = 1; A[step] = i; dfs(step+1);//dfs的精髓！ vis[i] = 0;//不要忘记重置这个数字的状态，因为需要再次使用

传送门 分析： 非常经典的费用流的模型吧，也可以通过二分图最大匹配去做，但是鉴于二分图最大匹配的算法存在一定的局限性，故还是学一学较为通用的费用流的做法。 这道题目中本质上要讨论的问题跟运输问题， 运输问题 是一致的。 因为考虑到每个人只能被分配到一种货物，每种货物只能被一个人所分配，因此，我们不妨用流量将他们限流。 我们创建一个超级源地 \(sp\) ，将 \(sp\) 跟每个人连一条流量为 \(1\) ，费用为 \(0\) 的边。 同时我们创建一个超级汇点 \(ep\) ，将每一种货物跟 \(ep\) 都连一条流量为 \(1\) ，费用为 \(0\) 的边。 同时，对于每一个人和货物，我们对他们连一条流量为无穷的边。 因为每个人只能从超级源点获取最多 \(1\) 点的流量，每种货物只能向超级汇点传送最多 \(1\) 点的流量，因此当这个图满流时，能够保证每个人一定会配对最多一个货物，即达到我们限流的要求。 而如果我们需要求解最小花费，我们只需要将人和货物的边加上的费用取 \(val_{ij}\) ，最后在这张图上跑最小费用最大流后最小费用即为答案。 而如果我们需要求解最大花费，我们只需要将人和货物的边加上的费用取相反数 \(-val_{ij}\) ，最后在这张图上跑最小费用最大流后最小费用的相反数即为答案。 代码： #include <bits/stdc++.h>

Rikka with Cake #include <bits/stdc++.h> using namespace std; const int maxn=2000; int match[maxn],match1[maxn],a[maxn][maxn],m,n,vis[maxn],k,ans,ans1; bool dfs(int x) { for (int i=1; i<=m; i++) { if (a[x][i]&&!vis[i]) { vis[i]=1; if (match[i]==0||dfs(match[i])) { match[i]=x; return 1; } } } return 0; } int main() { scanf("%d%d%d", &n, &m, &k); for (int i = 1, u, v; i <= k; i++) { scanf("%d%d", &u, &v); a[u][v] = 1; } for (int i = 1; i <= n; i++) { memset(vis, 0, sizeof(vis)); if (dfs(i)) { ans++; } } for (int i = 1; i <= m; i++) { match1[i] = match[i]; } for (int i = 1; i <= n; i++) { for

链接： P1433 --------------------------------------------------------------- 一道很水的搜索题，唯一的难点就是预处理，不过公式都写出来了也没什么难的 坑点还是有的，比如说有一个（两个点）的坐标都是一堆小数，就会wa掉 再也没什么难的了 ---------------------------------------------------------------- #include<iostream> #include<cmath> #include<cstdio> #include<windows.h> using namespace std; int vis[100]; int n; double dis[30][30]; double x[30]; double y[30]; double ans=1000090; char c; void dfs(int p,double diss,int cnt){ if(diss>ans) return ; if(vis[p]) return ; if(cnt==n){ ans=min(ans,diss); return ; } vis[p]=1; for(int i=1;i<=n;++i) { if(!vis[i]) dfs(i,diss+dis[p][i],cnt