vis

目录 深度优先遍历（DFS） 邻接表（DFS） 邻接矩阵（DFS） 广度优先遍历（BFS） 邻接表（BFS 无层级统计） 邻接表（BFS 含层级统计） 邻接矩阵（BFS 无层级统计） 邻接矩阵（BFS 含层级统计） 深度优先遍历（DFS） 邻接表（DFS） #include <iostream> #include <vector> using namespace std; const int maxn=10; vector<int> g[maxn]; int n,vis[maxn]; void dfs(int v, int h) { vis[v]=1; // 层级相关处理，或者对当前访问顶点的处理 for(int i=0; i<g[v].size(); i++) { if(vis[g[v][i]]==0) { dfs(g[v][i],h+1); } } } void dfs_travel() { for(int i=0; i<n; i++) { if(vis[i]==0) { dfs(i,1); //起始高度假设为1 // 统计连通分量 } } } int main(int argc,char * argv[]) { scanf("%d",&n); int a,b; for(int i=0;i<n;i++){ scanf("%d %d",&a,&b); g[a].push_back

Abstract 在Mask-RCNN的基础上加一个在一段video clip中可以propagate instance masks的模块。这样可以参照clip最中间那个instances segmentation 来predict clip-level的instance tracks Method MaskProp以一个video的随机长度L作为输入然后输出一个video-level的instance seg tracks M^i，以及类别c^i和置信度s^i。 首先我们的方法要先建立一个clip-level的object instance tracks,clip长度为2T+1。T值既要满足GPU显存大小，也要能handle一定遮挡和模糊的能力。 然后把L个clip的track整合。 4.1. Video Mask R-CNN loss： t 代表一个clip里的centre frame，其中prop的loss如下 其中 是instance i 由clip的center frame 预测得到的seg 是t'的GT mask in frame t p是每个pixel location；总体上这个loss是一个soft IOU loss，会比普通的CEloss要好。 4.2. Mask Propagation Branch Overview mask propagation

LCA（最近公共祖先）.....可惜我只会用tarjan去做 真心感觉tarjan算法要比倍增算法要好理解的多，可能是我脑子笨吧略略略 最近公共祖先概念 ： 在一棵无环的树上寻找两个点在这棵树上深度最大的公共的祖先节点，也就是离这两个点最近的祖先节点。 最近公共祖先的应用：求解两个有且仅有一条确定的最短路径的路径 　　　　举个例子吧，如下图所示 ４ 和 ５ 的 最近公共祖先是２ ， ５ 和 ３ 的 最近公共祖先 是 １ ， ２ 和 １ 的 最近公共祖先 是 １ 。　 　　　　这就是最近公共祖先的基本概念了，那么我们该如何去求这个最近公共祖先呢？ Tarjan介绍： 　 通常初学者都会想到最简单粗暴的一个办法：对于每个询问，遍历所有的点，时间复杂度为 O(n*q)， 那么这个复杂度当然也就呵呵了。 　　 　so，　我们有求解LCA的特殊算法：Tarjan /DFS+ST/倍增 （因为我不会，所以不喜欢） 　　　　后两个算法都是在线算法，也很相似，时间复杂度在 O(logn)~O(nlogn) 之间，我个人认为较难理解。 　　　　有的题目是可以用线段树来做的，但是其代码量很大，时间复杂度也偏高，在 O(n)~O(nlogn) 之间，优点在于也是 简单粗暴 。 tarjan属于离线算法，所谓的离线算法就是说我们需要将所有的询问都读入后一次性输出

题目链接： 点击这里 vis数组标记判重，通过80% 数组元素全部相同时，时间复杂度为 O ( n ( n − 1 ) 2 ) O(\frac{n(n-1)}{2}) O ( 2 n ( n − 1 ) ​ ) ，超时： # include <iostream> # include <cstdio> # include <cstring> # include <algorithm> using namespace std ; int a [ 100010 ] ; bool vis [ 1000010 ] ; int main ( ) { int n ; scanf ( "%d" , & n ) ; for ( int i = 1 ; i <= n ; ++ i ) scanf ( "%d" , & a [ i ] ) ; vis [ a [ 1 ] ] = true ; for ( int i = 2 ; i <= n ; ++ i ) { while ( vis [ a [ i ] ] ) { a [ i ] ++ ; } vis [ a [ i ] ] = true ; } for ( int i = 1 ; i <= n ; ++ i ) printf ( "%d " , a [ i ] ) ; return 0 ; } 搜题解： 这题可以巧妙地利用并查集。 我们初始化 i

Problem: http://acm.hdu.edu.cn/showproblem.php?pid=1384 在每个区间[ai,bi]上至少选ci个元素组成集合Z，求Z最小时的元素个数 因为是求最小，所以差分约束转化为SPFA求最长路 每个ai,bi,ci转换成点ai指向点bi+1的边，边权为ci 求出最小的ai,Min，最大的bi,Max 加上(Max-Min+2)*2条有向边x->x+1(边权为0)x+1->x(边权为-1) x属于[Min,Max] 最后套上SPFA模版妥妥的 #include<cstdio> #include<cstring> #include<algorithm> #include<queue> using namespace std; #define MAXN 100010 int head[MAXN],n,m,Min,Max,dist[MAXN]; struct Edge{ int to,next,w; }e[MAXN*3]; void add_edge(int u,int v,int c){ e[m].to=v; e[m].w=c; e[m].next=head[u]; head[u]=m++; } void SPFA(int s){ bool vis[MAXN]; memset(vis,false,sizeof(vis)); for(int i

图论 拓扑排序 最小生成树 最短路 #include <bits/stdc++.h> #include <vector> #include <algorithm> using namespace std; const int MAXN = 1e5+10; int n, m; ////加带权边 //自建结构体 struct Edge { int v; int w; }; Edge make_Edge(int v, int w) { Edge cur; cur.v = v; cur.w = w; return cur; } vector<Edge> G[MAXN]; void addEdge(int u, int v,int w) { G[u].push_back(make_Edge(v, w)); G[v].push_back(make_Edge(u, w)); } //pair vector<pair<int, int>> A[MAXN]; void addedge(int u, int v, int w) { A[u].push_back(make_pair(v, w)); A[v].push_back(make_pair(u, w)); } int main() { system("pause"); return 0; } /**************************

个人感觉欧拉筛法是算在[ 1 - n ] 范围内求素数个数的算法；埃氏算法是算x(某一个数）前（包括x）有多少个素数的算法。 欧拉筛 const int maxn = 1e6 + 5 ; int ans [ maxn ] ; bool vis [ maxn ] ; int n , cnt ; // cnt表示在n的范围内，一共有cnt个素数 void shai ( ) { ans [ 1 ] = 0 ; for ( int i = 2 ; i <= n ; i ++ ) { if ( ! vis [ i ] ) ans [ ++ cnt ] = i ; for ( int j = 1 ; j <= cnt && i * ans [ j ] <= n ; j ++ ) { vis [ j ] = true ; if ( i % ans [ j ] == 0 ) break ; } } } 埃氏筛 const int maxn = 1e6 + 5 ; int ans [ maxn ] ; // ans[i]表示i以前（包括i）有多少个素数 bool vis [ maxn ] ; int n ; void shai ( ) { ans [ 1 ] = 0 ; for ( int i = 2 ; i <= n ; i ++ ) { if ( ! vis [ i ] ) { ans [ i

转自 https://www.cnblogs.com/ECJTUACM-873284962/p/6613379.html 首先是最近公共祖先的概念(什么是最近公共祖先？)： 　　　　在一棵没有环的树上，每个节点肯定有其父亲节点和祖先节点，而最近公共祖先，就是两个节点在这棵树上 深度最大 的 公共 的 祖先节点 。 　　　　换句话说，就是两个点在这棵树上 距离最近的公共祖先节点 。 　　　　所以LCA主要是用来处理当两个点仅有 唯一一条 确定的最短路径时的路径。 　　　　有人可能会问：那他本身或者其父亲节点是否可以作为祖先节点呢？ 　　　　答案是肯定的，很简单，按照人的亲戚观念来说， 你的父亲也是你的祖先 ，而LCA还可以 将自己视为祖先节点 。 　　　　举个例子吧，如下图所示 ４ 和 ５ 的 最近公共祖先是２ ， ５ 和 ３ 的 最近公共祖先 是 １ ， ２ 和 １ 的 最近公共祖先 是 １ 。　 　　　　这就是最近公共祖先的基本概念了，那么我们该如何去求这个最近公共祖先呢？ 　　　　通常初学者都会想到最简单粗暴的一个办法：对于每个询问，遍历所有的点，时间复杂度为 O(n*q) ，很明显， n和q一般不会很小 。 　　　　常用的求LCA的算法有：Tarjan/DFS+ST/倍增 　　　　后两个算法都是在线算法，也很相似，时间复杂度在 O(logn)~O(nlogn) 之间

2020年2月19日 vector vector的意思就是向量，在使用时可以看成最大大小为2e9的且大小可变的数组。更多详细内容可见 大佬的vector解析 。 今天的题难度比较亲民，但每道题都有点值得重视的地方。 林大OJ 1675 中间数 签到题。。看清楚输出什么，一开始输出的中间两数的平均数，人都傻了。 # include <bits/stdc++.h> using namespace std ; vector < int > a ; int main ( ) { int n , x ; while ( cin >> x && x ) { a . push_back ( x ) ; } n = a . size ( ) ; if ( n % 2 == 0 ) { printf ( "%d\n" , a [ n / 2 ] + a [ n / 2 - 1 ] ) ; } else printf ( "%d\n" , a [ ( n - 1 ) / 2 ] ) ; return 0 ; } 林大OJ 2128 锯齿矩阵 相当于利用vector开了一个二维数组，只不过比普通的二维数组更容易操作，且可以分别操作。还有就是注意输出空行和清空vector（多组输入）。 # include <bits/stdc++.h> using namespace std ; int n , m ,

【问题描述】 H国有n个城市，这n个城市用n-1条双向道路相互连通构成一棵树，1号城市是首都，也是树中的根节点。 H国的首都爆发了一种危害性极高的传染病。当局为了控制疫情，不让疫情扩散到边境城市（叶子节点所表示的城市），决定动用军队在一些城市建立检查点，使得从首都到边境城市的每一条路径上都至少有一个检查点，边境城市也可以建立检查点。但特别要注意的是，首都是不能建立检查点的。 现在，在H国的一些城市中已经驻扎有军队，且一个城市可以驻扎多个军队。一支军队可以在有道路连接的城市间移动，并在除首都以外的任意一个城市建立检查点，且只能在一个城市建立检查点。一支军队经过一条道路从一个城市移动到另一个城市所需要的时间等于道路的长度（单位：小时）。 请问最少需要多少个小时才能控制疫情。注意：不同的军队可以同时移动。 【输入】 输入文件名为blockade.in。 第一行一个整数n，表示城市个数。 接下来的n-1行，每行3个整数，u、v、w，每两个整数之间用一个空格隔开，表示从城市u到城市v有一条长为w的道路。数据保证输入的是一棵树，且根节点编号为1。 接下来一行一个整数m，表示军队个数。 接下来一行m个整数，每两个整数之间用一个空格隔开，分别表示这m个军队所驻扎的城市的编号。 【输出】 输出文件为blockade.out。 共一行，包含一个整数，表示控制疫情所需要的最少时间。如果无法控制疫情则输出