二分图最大匹配
Ku二分图最大权匹配(KM算法)hn
Maigo的KM算法讲解(的确精彩)顶点Ｙｉ的顶标为B［i]，顶点Xi与Yj之间的边权为w[ｉ,j]。
在算法执行过程中的任一时刻，对于任一条边(ｉ,j),A［i]+B[j]>=w［i,ｊ]始终成立。
KM 算法的正确性基于以下定理：* 若由二分图中所有满足A［i］+B[j]=ｗ[ｉ,ｊ］的边（i，ｊ)构成的子图（称做相等子图）有完备匹配,那么这个完备匹配就是二分图的最大权匹配。
这个定理是显然的。
因为对于二分图的任意一个匹配，如果它包含于相等子图,那么它的边权和等于所有顶点的顶标和；如果它有的边不包含于相等子图,那么它的边权和小于所有顶点的顶标和。
所以相等子图的完备匹配一定是二分图的最大权匹配。
初始时为了使A［ｉ]＋B[j]>=w[i,j]恒成立,令A[i]为所有与顶点Xi关联的边的最大权，Ｂ[ｊ］＝0。
如果当前的相等子图没有完备匹配,就按下面的方法修改顶标以使扩大相等子图，直到相等子图具有完备匹配为止。
我们求当前相等子图的完备匹配失败了,是因为对于某个Ｘ顶点,我们找不到一条从它出发的交错路。
这时我们获得了一棵交错树,它的叶子结点全部是X顶点。
现在我们把交错树中X顶点的顶标全都减小某个值ｄ,Y顶点的顶标全都增加同一个值d，那么我们会发现：两端都在交错树中的边(i，j）,A［i]+B[j]的值没有变化。
也就是说,它原来属于相等子图，现在仍属于相等子图。
两端都不在交错树中的边(ｉ，ｊ)，A[i］和B[j]都没有变化。
也就是说,它原来属于(或不属于)相等子图，现在仍属于(或不属于)相等子图。
X端不在交错树中，Y端在交错树中的边(i，ｊ)，它的Ａ［ｉ]+B[j]的值有所增大。
它原来不属于相等子图,现在仍不属于相等子图。
X端在交错树中,Ｙ端不在交错树中的边（i,j),它的A［ｉ]+B[j]的值有所减小。
也就说,它原来不属于相等子图，现在可能进入了相等子图,因而使相等子图得到了扩大。
现在的问题就是求d值了。
二分图匹配(匈牙利算法)
设G=(V,{R})是一个无向图。
如顶点集V可分割为两个互不相交的子集，并且图中每条边依附的两个顶点都分属两个不同的子集。
则称图G为二分图。
v给定一个二分图G，在G的一个子图M中，M的边集{E}中的任意两条边都不依附于同一个顶点，则称M是一个匹配。
v选择这样的边数最大的子集称为图的最大匹配问题(maximal matching problem)v如果一个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配。
最大匹配在实际中有广泛的用处，求最大匹配的一种显而易见的算法是：先找出全部匹配，然后保留匹配数最多的。
但是这个算法的复杂度为边数的指数级函数。
因此，需要寻求一种更加高效的算法。
匈牙利算法是求解最大匹配的有效算法，该算法用到了增广路的定义(也称增广轨或交错轨)：若P是图G中一条连通两个未匹配顶点的路径，并且属M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M 的一条增广路径。
由增广路径的定义可以推出下述三个结论：v 1. P的路径长度必定为奇数，第一条边和最后一条边都不属于M。
v 2. P经过取反操作（即非M中的边变为M中的边，原来M中的边去掉）可以得到一个更大的匹配M’。
v 3. M为G的最大匹配当且仅当不存在相对于M的增广路径。
从而可以得到求解最大匹配的匈牙利算法：v(1)置M为空v(2)找出一条增广路径P，通过取反操作获得更大的匹配M’代替Mv(3)重复(2)操作直到找不出增广路径为止根据该算法，我选用dfs (深度优先搜索)实现。
程序清单如下：int match[i] //存储集合m中的节点i在集合n中的匹配节点,初值为-1。
int n,m,match[100]; //二分图的两个集合分别含有n和m个元素。
bool visit[100],map[100][100]; //map存储邻接矩阵。
bool dfs(int k){int t;for(int i = 0; i < m; i++)if(map[k][i] && !visit[i]){visit[i] = true;t = match[i];match[i] = k; //路径取反操作。
二分图相关问题
X X S X X
X X X X
X代表攻击范围，S代表骑 士
分析
对棋盘染色，设方格的坐标为(x,y)，x和y同奇 偶的方格对应X集合，不同奇偶的对应Y集合。 由于骑士沿着“日”字形路线攻击，所以每个 攻击肯定是处于X集合和Y集合之间，而不可 能在两个集合内部。 显然，转化后变为求二分图的最大独立集
匈牙利算法
简要说明：find函数用于判断从k点开始是否能 够找到一条交错路。对于每个可以与k匹配的 顶点j，假如它未被匹配，交错路就已经找到； 假如j已与某顶点x匹配，那么只需调用find(x) 来求证x是否可以与其它顶点匹配，如果返回 true的话，仍可以使j与k匹配；这就是一次 DFS。每次DFS时，要标记访问到的顶点 （cover[j]=true），以防死循环和重复计算。
例题分析
Hanoi Tower Troubles Again! (OIBH Contest)
ZOJ 1239 题目大意：给定柱子数N，按编号从小到大放球， 要求：如果该球不在最底数，则该球和它下面一个 球的编号之和必须为完全平方数。 问对于给定的N，最多能放多少球上去。 N<=50
例题分析
分析
铺放方法
1.2. .333 444. ..2.
Sample Output 4
分析
最小覆盖是覆盖所有的边，因此泥地对应边 建图方式类似于皇家卫士，也是利用行连通块 和列连通块做点，单位泥地对应二分图中的边 要求放最少的板覆盖全部的泥地，转化为求最 小覆盖
二分图最大独立集
图的独立集：寻找一个点集，其中任意两点在 图中无对应边 一般图的最大独立集是NP完全问题 二分图的最大独立集=图的点数-最大匹配数
二分图最小覆盖
图的覆盖：寻找一个点集，使得图中每一条边 至少有一点在该点集中
最大权匹配KM算法
最大权匹配KM算法
KM算法（Kuhn–Munkres算法，也称为匈牙利算法）是由Kuhn于
1955年和Munkres于1957年分别提出的，用于解决二分图最大匹配问题。
该算法的核心思想是基于匈牙利算法的增广路径，通过构建一个增广路径
来不断更新匹配，直到无法找到增广路径为止。
算法流程如下：
2.从G的每个未匹配顶点开始，通过增广路径将其标记为可增广点；
3.当存在增广路径时，将匹配的边进行反向操作，直到不存在增广路径；
4. 利用增广路径的反向操作可以修改lx和ly的值，使其满足特定
约束条件；
5.通过相等子图的扩展来实现增广路径的；
6.重复步骤3-5，直到不存在更多的增广路径；
7.返回找到的最大匹配。
具体实现时，对于增广路径的可以利用DFS或BFS等方法进行，当找
到一个增广路径时，通过反向操作修改匹配情况，并更新lx和ly的值。
同时，算法还可以使用增广路径来调整优化标号，以减少匹配时间。
KM算法是一种高效的解决最大权匹配问题的方法，其时间复杂度为
O(V^3)，其中V为图的顶点数。
算法的核心思想是利用二分图中的相等子
图来查找增广路径，并通过修改顶点的标号来实现最大匹配。
总之，最大权匹配KM算法是一个解决带权无向二分图最大匹配问题
的高效算法，通过不断寻找增广路径并调整顶点的标号来实现最大权匹配。
它的思想简单而有效，可以广泛应用于各种实际问题中。
二分图匹配
二分图匹配一、二分图的概念二分图又称作二部图，是图论中的一种特殊模型。
设G=(V,{R})是一个无向图。
如顶点集V可分割为两个互不相交的子集，并且图中每条边依附的两个顶点都分属两个不同的子集。
则称图G为二分图。
二、最大匹配给定一个二分图G，在G的一个子图M中，M的边集{E}中的任意两条边都不依附于同一个顶点，则称M是一个匹配。
选择这样的边数最大的子集称为图的最大匹配问题(maximal matching problem)如果一个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配。
三、匈牙利算法求最大匹配的一种显而易见的算法是：先找出全部匹配，然后保留匹配数最多的。
但是这个算法的复杂度为边数的指数级函数。
因此，需要寻求一种更加高效的算法。
1、增广路的定义(也称增广轨或交错轨)：若P是图G中一条连通两个未匹配顶点的路径，并且属M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广路径。
由增广路的定义可以推出下述三个结论：●P的路径长度必定为奇数，第一条边和最后一条边都不属于M。
●P经过取反操作可以得到一个更大的匹配M’。
●M为G的最大匹配当且仅当不存在相对于M的增广路径。
2、用增广路求最大匹配(称作匈牙利算法，匈牙利数学家Edmonds于1965年提出)。
算法轮廓：(1)置M为空(2)找出一条增广路径P，通过取反操作获得更大的匹配M’代替M(3)重复(2)操作直到找不出增广路径为止程序清单：Function find(k:integer):integer;var st,sf,i,j,t:integer;queue,father:array[1..100] of integer;beginqueue[1] := k; st := 1; sf := 1;fillchar(father,sizeof(father),0);repeatfor i:=1 to n doif (father[i]=0)and(a[queue[st],i]=1) thenbeginif match2[i]<>0 thenbegininc(sf);queue[sf] := match2[i];father[i] := queue[st];end elsebeginj := queue[st];while true dobegint := match1[j];match1[j] := i;match2[i] := j;if t = 0 then break;i := t; j := father[t];end;find := 1;exit;end;end;inc(st);until st>sf;find := 0;end;在主程序中调用下面的程序即可得出最大匹配数。
匈牙利匹配算法的原理
匈牙利匹配算法的原理匈牙利匹配算法（也被称为二分图匹配算法或者Kuhn-Munkres算法）是用于解决二分图最大匹配问题的经典算法。
该算法由匈牙利数学家Dénes Kőnig于1931年提出，并由James Munkres在1957年进行改进。
该算法的时间复杂度为O(V^3)，其中V是图的顶点数。
匹配问题定义：给定一个二分图G=(X,Y,E)，X和Y分别代表两个不相交的顶点集合，E表示连接X和Y的边集合。
图中的匹配是指一个边的集合M，其中任意两条边没有公共的顶点。
匹配的相关概念：1.可增广路径：在一个匹配中找到一条没有被占用的边，通过这条边可以将匹配中的边个数增加一个，即将不在匹配中的边添加进去。
2. 增广路径：一个可增广路径是一个交替序列P=v0e1v1e2v2...ekvk，其中v0属于X且不在匹配中，v1v2...vk属于Y且在匹配中，e1e2...ek在原图中的边。
3.增广轨：一个交替序列形如V0E1V1E2...EkVk，其中V0属于X且不在匹配中，V1V2...Vk属于Y且在匹配中，E1E2...Ek在原图中的边。
增广轨是一条路径的特例，它是一条从X到Y的交替序列。
1.初始时，所有的边都不在匹配中。
2.在X中选择一个点v0，如果v0已经在匹配中，则找到与v0相连的在Y中的顶点v1、如果v1不在匹配中，则(v0,v1)是可增广路径的第一条边。
3. 如果v1在匹配中，则找到与v1相连的在X中的顶点v2，判断v2是否在匹配中。
依此类推，直到找到一个不在匹配中的点vn。
4.此时，如果n是奇数，则(n-1)条边在匹配中，这意味着我们找到了一条增广路径。
如果n是偶数，则(n-1)条边在匹配中，需要进行进一步的处理。
5.如果n是偶数，则将匹配中的边和非匹配中的边进行颠倒，得到一个新的匹配。
6.对于颠倒后的匹配，我们再次从第2步开始，继续寻找增广路径。
7.重复步骤2到步骤6，直到找不到可增广路径为止，此时我们得到了最大匹配。
最大二分图匹配（匈牙利算法）
最大二分图匹配（匈牙利算法）二分图指的是这样一种图：其所有的顶点分成两个集合M和N，其中M或N中任意两个在同一集合中的点都不相连。
二分图匹配是指求出一组边，其中的顶点分别在两个集合中，并且任意两条边都没有相同的顶点，这组边叫做二分图的匹配，而所能得到的最大的边的个数，叫做最大匹配。
计算二分图的算法有网络流算法和匈牙利算法（目前就知道这两种），其中匈牙利算法是比较巧妙的，具体过程如下（转自组合数学）：令g=（x,*,y）是一个二分图，其中x={x1,x2...},y={y1,y2,....}.令m为g中的任意匹配。
1。
将x的所有不与m的边关联的顶点表上￥，并称所有的顶点为未扫描的。
转到2。
2。
如果在上一步没有新的标记加到x的顶点上，则停，否则，转33。
当存在x被标记但未被扫描的顶点时，选择一个被标记但未被扫描的x的顶点，比如xi，用（xi）标记y 的所有顶点，这些顶点被不属于m且尚未标记的边连到xi。
现在顶点xi 是被扫描的。
如果不存在被标记但未被扫描的顶点，转4。
4。
如果在步骤3没有新的标记被标记到y的顶点上，则停，否则转5。
5。
当存在y被标记但未被扫描的顶点时。
选择y的一个被标记但未被扫描的顶点，比如yj，用（yj）标记x的顶点，这些顶点被属于m且尚未标记的边连到yj。
现在，顶点yj是被扫描的。
如果不存在被标记但未被扫描的顶点则转道2。
由于每一个顶点最多被标记一次且由于每一个顶点最多被扫描一次，本匹配算法在有限步内终止。
代码实现：bfs过程：#include<stdio.h>#include<string.h>main(){bool map[100][300];inti,i1,i2,num,num1,que[300],cou,stu,match1[100],match2[300],pqu e,p1,now,prev[300],n;scanf("%d",&n);for(i=0;i<n;i++){scanf("%d%d",&cou,&stu);memset(map,0,sizeof(map));for(i1=0;i1<cou;i1++){scanf("%d",&num);for(i2=0;i2<num;i2++){scanf("%d",&num1);map[i1][num1-1]=true;}}num=0;memset(match1,int(-1),sizeof(match1)); memset(match2,int(-1),sizeof(match2)); for(i1=0;i1<cou;i1++){p1=0;pque=0;for(i2=0;i2<stu;i2++){if(map[i1][i2]){prev[i2]=-1;que[pque++]=i2;}elseprev[i2]=-2;}while(p1<pque){now=que[p1];if(match2[now]==-1)break;p1++;for(i2=0;i2<stu;i2++){if(prev[i2]==-2&&map[match2[now]][i2]){prev[i2]=now;que[pque++]=i2;}}}if(p1==pque)continue;while(prev[now]>=0){match1[match2[prev[now]]]=now; match2[now]=match2[prev[now]]; now=prev[now];}match2[now]=i1;match1[i1]=now;num++;}if(num==cou)printf("YES\n");elseprintf("NO\n");}}dfs实现过程：#include<stdio.h>#include<string.h>#define MAX 100bool map[MAX][MAX],searched[MAX]; int prev[MAX],m,n;bool dfs(int data){int i,temp;for(i=0;i<m;i++){if(map[data][i]&&!searched[i]){searched[i]=true;temp=prev[i];prev[i]=data;if(temp==-1||dfs(temp))return true;prev[i]=temp;}}return false;}main(){int num,i,k,temp1,temp2,job;while(scanf("%d",&n)!=EOF&&n!=0) {scanf("%d%d",&m,&k);memset(map,0,sizeof(map));memset(prev,int(-1),sizeof(prev)); memset(searched,0,sizeof(searched));for(i=0;i<k;i++){scanf("%d%d%d",&job,&temp1,&temp2); if(temp1!=0&&temp2!=0)map[temp1][temp2]=true;}num=0;for(i=0;i<n;i++){memset(searched,0,sizeof(searched)); dfs(i);}for(i=0;i<m;i++){if(prev[i]!=-1)num++;}printf("%d\n",num);}}。
konig 定理
konig 定理
Konig定理是图论中的一个重要定理，它是由匈牙利数学家Dénes Konig在1936年首次证明的。
这个定理主要应用于二分图（bipartite graph）的研究中，二分图是一种特殊的图，其中所有的顶点都可以被分成两个互不相交的子集，并且每一条边都连接这两个子集中的一个顶点。
Konig定理的表述如下：在一个二分图中，最大匹配数等于最小点覆盖数。
换句话说，一个图中的最大匹配数等于覆盖该图中所有顶点所需的最小边数。
为了更好地理解这个定理，我们可以先了解一下什么是匹配和点覆盖。
在图论中，一个匹配是一个边的集合，其中任意两条边都不共享一个顶点。
最大匹配是指一个匹配中包含的边数最多。
点覆盖是指一个顶点的集合，该集合中的任意顶点都是边的一个端点。
最小点覆盖是指覆盖所有顶点所需的最小顶点数。
根据Konig定理，在二分图中，最大匹配数等于最小点覆盖数。
这个定理的证明过程需要使用到一些图论中的技巧和结论，例如Kőnig-Egerváry定理和Hall定理等。
这个定理的应用非常广泛，它可以用于解决一些组合优化问题，例如最大匹配问题和最小点覆盖问题等。
此外，Konig定理还可以用于证明一些其他图论中的结论，例如Kőnig-Egerváry定理和Hall定理等。
二分图最大匹配及常用建图方法
算法———艺术二分图匹配剖析很多人说，算法是一种艺术。
但是对于初学者的我，对算法认识不是很深刻，但偶尔也能感受到他强大的魅力与活力。
这让我追求算法的脚步不能停止。
下面我通过分析匈牙利算法以及常用建图方式，与大家一起欣赏算法的美。
匈牙利算法匈牙利算法是用来解决最大二分图匹配问题的，所谓二分图即“一组点集可以分为两部分，且每部分内各点互不相连，两部分的点之间可以有边”。
所谓最大二分图匹配即”对于二分图的所有边，寻找一个子集，这个子集满足两个条件，1：任意两条边都不依赖于同一个点。
2：让这个子集里的边在满足条件一的情况下尽量多。
首先可以想到的是，我们可以通过搜索，找出所有的这样的满足上面条件的边集，然后从所有的边集中选出边数最多的那个集合，但是我们可以感觉到这个算法的时间复杂度是边数的指数级函数，因此我们有必要寻找更加高效的方法。
目前比较有效的方法有匈牙利算法和通过添加汇点和源点的网络流算法，对于点的个数都在200 到300 之间的数据，我们是采取匈牙利算法的，因为匈牙利算法实现起来要比网络流简单些。
下面具体说说匈牙利算法：介绍匈牙利之前，先说说“增广轨”。
定义：若P是图G中一条连通两个未匹配顶点的路径，并且属最大匹配边集M的边和不属M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广轨定义总是抽象的下面通过图来理解它。
图中的线段（2->3, 3->1, 1->4）便是上面所说的p路径，我们假定边（1,3）是以匹配的边，（2,3）（1,4）是未匹配的边，则边（4,1）边（1,3）和边（3,2）在路径p上交替的出现啦，那么p就是相对于M的一条增广轨，这样我们就可以用边1,4 和边2,3来替换边1,3 那么以匹配的边集数量就可以加1,。
匈牙利算法就是同过不断的寻找增广轨实现的。
很明显如果二分图的两部分点分别为n 和m，那么最大匹配的数目应该小于等于MIN（n,m）; 因此我们可以枚举任第一部分（的二部分也可以）里的每一个点，我们从每个点出发寻找增广轨，最后吧第一部分的点找完以后，就找到了最大匹配的数目，当然我们也可以通过记录找出这些边。
[hdu1533]二分图最大权匹配最小费用最大流
[hdu1533]⼆分图最⼤权匹配最⼩费⽤最⼤流题意：给⼀个n*m的地图，'m'表⽰⼈，'H'表⽰房⼦，求所有⼈都回到房⼦所⾛的距离之和的最⼩值（距离为曼哈顿距离）。
思路：⽐较明显的⼆分图最⼤权匹配模型，将每个⼈向房⼦连⼀条边，边权为曼哈顿距离的相反数（由于是求最⼩，所以先取反后求最⼤，最后再取反回来即可），然后⽤KM算法跑⼀遍然后取反就是答案。
还可以⽤最⼩费⽤最⼤流做，⽅法是：从源点向每个⼈连⼀条边，容量为1，费⽤为0，从每个房⼦向汇点连⼀条边，容量为1，费⽤为0，从每个⼈向每个房⼦连⼀条边，容量为1，费⽤为曼哈顿距离的值，建好图后跑⼀遍最⼩费⽤最⼤流就是答案。
附上代码：（1）KM算法，40ms左右（2）最⼩费⽤最⼤流，400+ms（1）1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84/* ******************************************************************************** */#include <iostream> //#include <cstdio> //#include <cmath> //#include <cstdlib> //#include <cstring> //#include <vector> //#include <ctime> //#include <deque> //#include <queue> //#include <algorithm> //#include <map> //#include <cmath> //using namespace////#define pb push_back //#define mp make_pair //#define X first //#define Y second //#define all(a) (a).begin(), (a).end() //#define fillchar(a, x) memset(a, x, sizeof(a)) ////void int int for int scanf"%d"//void void int scanf"%d"template typename//void int void int int int//while scanf"%d"void template typename// void const template typename typename// void const const", "template typename//void int while", "////typedef int int//typedef long long//typedef long long////template typename bool const return false true// template typename bool const return false true// template typename//void const for int// template typename//void const for int////const double acos/////* -------------------------------------------------------------------------------- */structconst static intconst static intintintintintvoid int int intbool inttruefor intiftrueifreturn trueelse if//j属于B，且不在交错路径中return falseint int intthis thisintmemset sizeofmemset sizeofmemset sizeofforforforforwhile84858687888990919293949596979899 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135（2）12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849whilememset sizeofmemset sizeofif break//从i点出发找到交错路径则跳出循环for//取最⼩的slack[j]iffor//集合A中位于交错路径上的-diffor//集合B中位于交错路径上的+difelse//注意修改不在交错路径上的slack[j]intforif (~match[j])return//点从0开始编号intreturn abs absint#ifndef ONLINE_JUDGEfreopen"in.txt""r"#endif // ONLINE_JUDGEintwhilefor intcharscanf"%s"for intif'H'if'm'for intfor intreturn/* ******************************************************************************** *//* ******************************************************************************** */#include <iostream> //#include <cstdio> //#include <cmath> //#include <cstdlib> //#include <cstring> //#include <vector> //#include <ctime> //#include <deque> //#include <queue> //#include <algorithm> //#include <map> //#include <cmath> //using namespace////#define pb push_back //#define mp make_pair //#define X first //#define Y second //#define all(a) (a).begin(), (a).end() //#define fillchar(a, x) memset(a, x, sizeof(a)) ////void int int for int scanf"%d"//void void int scanf"%d"template typename//void int void int int int//while scanf"%d"void template typename// void const template typename typename// void const const", "template typename//void int while", "////typedef int int//typedef long long//typedef long long////template typename bool const return false true// template typename bool const return false true// template typename//void const for int// template typename//void const for int////const double acos/////* -------------------------------------------------------------------------------- */structconst static intconst static intstruct49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145structintint int int intintintintvoid intthisfor intvoid int int int intintbool int int int intfor intmemset sizeofintwhileintfor intififif return falseintwhilereturn trueint int intintwhilereturnintreturn abs absint#ifndef ONLINE_JUDGEfreopen"in.txt""r"#endif // ONLINE_JUDGEintwhilefor intcharscanf"%s"for intif'H'if'm'for intfor intfor intfor intreturn/* ******************************************************************************** */。