匹配问题

最新推荐文章于 2022-10-29 10:39:29 发布
最新推荐文章于 2022-10-29 10:39:29 发布
阅读量959 收藏 4
点赞数
分类专栏： ACM--图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49959202/article/details/108721064
版权

文章目录

匹配问题

1. 算法分析

匹配问题可以转换为二分匹配来处理，匈牙利算法求解；选择问题中有部分可以转换为点覆盖集问题，选择a或者b，那么a<->b，然后每条边只能选择其中一个。

1.1 几个重要概念

1.交替路：从一个未匹配点出发，依次经过非匹配边、匹配边、非匹配边…形成的路径叫交替路
2.增广路：从一个未匹配的点出发，走交替路，如果途径另一个未匹配点，则这条交替路称为增广路

1.2 二分图判定

一张图是二分图当且仅当图中没有奇数环，二分图必然不含有奇数环

1.3 二分图点覆盖、独立集和最小路径点覆盖

最大匹配数=最小点覆盖=总点数-最大独立集=总点数-最小路径点覆盖

1.3.1 二分图的点覆盖

最小点覆盖： 求一个最小的点集S，使得图中任意一条边都有至少一个端点属于S。
定理： 最小覆盖集中点数目等于二分图的最大匹配包含的边数

1.3.2 二分图的独立集

定义： 一个独立集内的点没有连边
定理： 一个二分图的最大独立集内点个数等于总个数n-最大匹配个数
最大团: 一个点集的所有点间都有边相连,一张图G的最大独立集的补集就是最大团

1.3.3 DAG的最小路径点覆盖

DAG的最小路径点覆盖是描述： 给定一张有向无环图，要求用尽量少的不相交的简单路径，覆盖有向无环图的所有顶点（也就是每个顶点恰好被覆盖一次）。
拆点： 把原图中的每个点拆分成两个点，比如i点拆成i点和i’点，把原来的连边和新点连接起来，比如说原图i->j，那么拆点后，把i和j’连边(i和j不用连边),即i->j’，这样的方式组成一张新图

Screenshot_20201224_133504.jpg

定理： 最小路径点覆盖的数目等于原先所有的点数n-新图最大二分匹配的数目

优化： i->j’的边可以直接建为i->j。由于这里新建完的图是二分图，左部图是<=n的点，右部图是>=n的点，那么本来i->j’的边可以直接建为i->j，也就是说把左部图里的点j放在右部图内，然后对于左右部图都做二分匹配，本来这样计算答案要除以2，但是左部图和右部图规模都减小了1/2，因此抵消了。

1.3.4 DAG的最小路径可重复点覆盖

1.利用传递闭包把DAG变成一张没有重复点的图
2.套用上述求DAG的最小路径覆盖的算法

1.3.5 有向环覆盖问题

问题描述： 给你一个N个顶点M条边的带权有向图，要你把该图分成一个或多个不相交的有向环（点和边都不相交）。且所有定点都被有向环覆盖。问你该有向环所有权值的总和最小是多少?

结论： 原图有向环最大权值覆盖=新图最优匹配。把任意一个顶点i都分成两个,即i和i’. 如果原图存在i->j的边,那么二分图有i->j’的边.然后跑最优匹配。

拓展： 如果，改为无向图，问你无向环最大权值覆盖？答案也是一样的。只是在建图的时候把有向改为无向即可。

进一步结论：

① 如果原图能由多个不相交的有向环覆盖，那么二分图必然存在完备匹配。他们互为充要条件，也就是说如果二分图存在完备匹配,那么原图必定能由几个不想交的有向环覆盖。因此如果只需要判定十分存在有向环覆盖，只需要判断跑最大匹配判断即可。

② 如果原图存在权值最大的有向环覆盖，那么二分图的最优匹配一定就是这个值。即权值最大的有向环覆盖在数值上等于改图的最优匹配值。

1.4 各类二分匹配问题

1.4.1 最大匹配

在一张无权的二分图中，一个图所有匹配中，所含匹配边数最多的匹配，称为这个图的最大匹配。找最大匹配数可以使用匈牙利算法实现 O ( n 2 ) O(n^2) O(n2)，也可以使用最大流算法(dinic)解决 O ( n m 2 ) O(nm^2) O(nm2)。

1.4.2 完美（备）匹配

在一张无权的二分图中，如果一个图的某个匹配中，所有的顶点都是匹配点，那么它就是一个完美匹配。完美匹配一定是最大匹配，但并非每个图都存在完美匹配。

1.4.3 最大权匹配/最优匹配

最优匹配就是指在带权边的二分图中，求一个匹配使得匹配边上的权值和最大。如果匹配是完美匹配，那么这个问题可以使用km算法来实现，它的算法复杂度是 O ( n 3 ) O(n^3) O(n3)。如果匹配不一定是完美匹配，那么将其转化为最小费用最大流来做，它的复杂度是 O ( n 2 m ) O(n^2m) O(n2m)。

1.4.4 多重匹配

多重匹配就是解决一连多的问题.

1.4.4.1 多重最大匹配

在一张无权二分图中，找到一对多的最大匹配。使用网络流算法解决:在原图上建立源点S和汇点T，S向每个X方点连一条容量为该X方点L值的边，每个Y方点向T连一条容量为该Y方点L值的边，原来二分图中各边在新的网络中仍存在，容量为1（若该边可以使用多次则容量大于1），求该网络的最大流，就是该二分图多重最大匹配的值。也可以使用匈牙利算法解决，只需要一个点维护多个匹配点即可。

1.4.4.2 多重最优匹配

在一张带权二分图中，找到一对多的最大权匹配。使用网络流算法解决。在原图上建立源点S和汇点T，S向每个X方点连一条容量为该X方点L值、费用为0的边，每个Y方点向T连一条容量为该Y方点L值、费用为0的边，原来二分图中各边在新的网络中仍存在，容量为1（若该边可以使用多次则容量大于1），费用为该边的权值。求该网络的最大费用最大流，就是该二分图多重最优匹配的值。

1.5 一般图匹配

带花树算法 O ( n 3 ) O(n^3) O(n3)

2. 模板

2.1 染色法判断是否为二分图

#include <bits/stdc++.h>

using namespace std;

int const N = 1e5 + 10;
int e[N * 2], ne[N * 2], h[N], idx, color[N];  // color记录每个点颜色
int n, m;

// 建立邻接表
void add(int a, int b) {
   
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

// 判断是否u号点可以打上c的颜色
int dfs(int u, int c) {
   
    color[u] = c;  // 给u号点打上c的颜色
    for (int i = h[u]; i != -1; i = ne[i]) {
     // 遍历所有与i号点相连的点
        int j = e[i];  // 看j号点
        if (!color[j]) {
     // 如果j号点没有染色
            if (!dfs(j, 3 - c)) return 0;  // 如果j号点染色3-c过程中失败
        }
        if (color[j] == c) return 0;  // 如果j号点也染色c颜色
    }
    return 1;  // 如果u号点的所有邻点都没有染色失败
}

int main() {
   
    memset(h, -1, sizeof h);  // 初始化h
    cin >> n >> m;  // 输入顶点数和边数
    for (int i = 0; i < m ; ++i) {
     // 读入边信息
        int a, b;
        scanf("%d %d", &a, &b);
        add(a, b), add(b, a);  // 无向边
    }
    int flg = 1;  // flg记录染色是否成功，成功为1，失败为0
    for (int i = 1; i <= n; ++i) {
     // 从1号点开始枚举
        if (!color[i]) {
     // 如果i号点为染色
            if (!dfs(i, 1)) {
     // 如果i号点染色失败
                flg = 0;  // flg 打上失败标记
                break;
            }
        }
    }
    if (flg) cout << "Yes\n";
    else cout << "No\n";
    return 0;
}

2.2 二分图最大匹配

2.2.1 匈牙利算法(O(VE))
#include <bits/stdc++.h>

using namespace std;

int const N = 110, M = 1010;
int e[M], ne[M], idx, h[N], match[N], st[N];  // match[j] = x: 右半部分的j匹配左半部分的x，st[j] = 1：右半部分的j匹配到人了
int n, m, k;

// 建立邻接表
void add(int a, int b) {
   
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

/* 邻接矩阵写法
bool find(int x) {
    for (int i = 1; i <= n; ++i) {
        if (l[x][i]) continue;  // 没有边
        if (!st[i]) {
            st[i] = 1;
            if (!match[i] || find(match[i])) {
                match[i] = x;
                return true;
            }
        }
    }
    return false;
}
*/

// 找左半部分的x是否能够在右半部分找到匹配的对象
bool find(int x) {
   
    for (int i = h[x]; i != -1; i = ne[i]) {
    // 遍历所有与x之间相连的点
        int j = e[i];  // 点为j
        if (!st[j]) {
     // 如果j没有匹配过
            st[j] = 1;  // 记录j匹配过
            if (!match[j] || find(match[j])) {
     // 如果右半部分的j没有匹配到左半部分的人或者j匹配到的可以去匹配其他右半部分的人
                match[j] = x;  // 记录右半部分的j和左半部分的x匹配
                return true;  // 找到x的匹配对象
            }
        }
    }
    return false;  // 全部都遍历仍然没有成功，返回false
}

int hungary() {
   
    int res = 0;  // 记录结果数目
    for (int i = 1; i <= n; ++i) {
    // 从左半部分向右半部分匹配  
        memset(st, 0, sizeof st);  // 每次匹配时对右半部分的女生情况匹配情况
        if (find(i)) res++;  // 如果能够找到，res加一
    }
    return res;
}

int main() {
   
    while (scanf("%d %d %d", &n, &m, &k) != EOF && n != 0) {
   
        memset(h, -1, sizeof h);  // 初始化h
        memset(e, 0, sizeof e);
        memset(ne, 0, sizeof ne);
        memset(match, 0, sizeof match);
        idx = 0;
        for (int i = 0; i < k; ++i) {
     // 读入边信息
            int a, b, c;
            scanf("%d %d %d", &c, &a, &b);
            if (!a || !b) continue;  // 起始点是0，不用覆盖
            add(a, b);  // 只需要add一次即可，因为二分匹配时只需要从左半部分向右半部分匹配就行
        }

        cout << hungary() << endl;
    }
    
    return 0;
}
2.2.2 hopcroft-karp算法(O(sqrt(V) * E ))
#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;
int const MAXN = 3e3 + 10, MAXM = MAXN * MAXN, INF = 1e9 + 10;
int n, m, T, t, kase = 1;
int idx, h[MAXN], ne[MAXM], e[MAXM], xline[MAXN], yline[MAXN], dx[MAXN], dy[MAXN], st[MAXN], dis;

void add(int a, int b) {
   
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

struct Node {
   
    int x, y, v;
}node[MAXN];

int check(int a, int x, int y) {
   
    double dis = sqrt((node[a].x - x) * (node[a].x - x) + (node[a].y - y) * (node[a].y - y));
    return dis/(double)node[a].v <= t;
}

int bfs() {
   
    queue<int> q;
    dis = INF;  // dis是全局变量
    memset(dx, -1, sizeof(dx));  // dx和dy每次bfs都需要初始化
    memset(dy, -1, sizeof(dy));
    for (int i = 1; i <= m; i++)   // 左部点
        if (xline[i] == -1) {
   
            q.push(i);
            dx[i] = 0;
        }
    while (!q.empty()) {
   
        int t = q.front();
        q.pop();
        if (dx[t] > dis) break;
        for (int i = h[t]; ~i; i = ne[i]) {
   
            int j = e[i];
            if (dy[j] == -1) {
   
                dy[j] = dx[t] + 1;
                if (yline[j] == -1) dis = dy[j];
                else {
   
                    dx[yline[j]] = dy[j] + 1;
                    q.push(yline[j]);
                }
            }
        }
    }
    return dis != INF;
}

int find(int t) {
   
    for (int i = h[t]; ~i; i = ne[i]) {
   
        int j = e[i];
        if (!st[j] && dy[j] == dx[t] + 1) {
   
            st[j] = 1;
            if (yline[j] != -1 && dy[j] == dis) continue;
            if (yline[j] == -1 || find(yline[j])) {
   
                yline[j] = t, xline[t] = j;
                return 1;
            }
        }
    }
    return 0;
}

int Maxmatch() {
     //最大匹配
    int res = 0;
    while (bfs()) {
   
        memset(st, 0, sizeof(st));
        for (int i = 1; i <= m; i++)  // 遍历左部图每个点
            if (xline[i] == -1 && find(i)) res++;
    }
    return res;
}

int main() {
   
    cin >> T;
    while(T--) {
   
        memset(xline, -1, sizeof(xline));  // 初始化左边标记
        memset(yline, -1, sizeof(yline));  // 初始化右边标记
        memset(h, -1, sizeof h);
        scanf("%d", &t);
        scanf("%d", &m);  // 左部m个点，右部n个点
        idx = 0;
        for (int i = 1; i <= m; ++i) scanf("%d%d%d", &node[i].x, &node[i].y, &node[i].v);
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) {
   
            int x, y;
            scanf("%d%d", &x, &y);
            for (int j = 1; j <= m; ++j) {
   
                if (check(j, x, y)) add(j, i);  // 如果能够建边
            }
        }
        printf("Scenario #%d:\n", kase++);
        cout << Maxmatch() << endl << endl;
    }   
    return 0;
}

2.3 二分图最优匹配（必须是完美匹配）

// 本板子是求最大权的最优匹配，如果是求最小权值的最优匹配，那么只需要将所有的边权取负值，然后再次跑km算法，最后答案取反即可。
#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
LL const INF = 0x3f3f3f3f3f3f3f3f;
int const MAXN = 500;

int n;
LL g[MAXN][MAXN], hl[MAXN], hr[MAXN], slk[MAXN];
int fl[MAXN], fr[MAXN], pre[MAXN], vl[MAXN], vr[MAXN], q[MAXN], ql, qr;
LL a[MAXN], b[MAXN], p[MAXN], c[MAXN];

inline int check(int i) {
   
    vl[i] = 1;
    if (fl[i] != -1) {
   
        q[qr++] = fl[i];
        vr[fl[i]] = 1;
        return 1;
    }
    while (i != -1) {
   
        fl[i] = pre[i];
        swap(i, fr[fl[i]]);
    }
    return 0;
}

void bfs(int s) {
   
    for (int i = 1; i <= n; i++) vl[i] = vr[i] = 0, slk[i] = INF;
    for (vr[q[ql = 0] = s] = qr = 1;;) {
   
        for (LL d; ql < qr;) {
   
            for (int i = 1, j = q[ql++]; i <= n; i++) {
   
                if (!vl[i] && slk[i] >= (d = hl[i] + hr[j] - g[i][j])) {
   
                    pre[i] = j;
                    if (d)
                        slk[i] = d;
                    else if (!check(i))
                        return;
                }
            }
        }
        LL d = INF;
        for (int i = 1; i <= n; i++) {
   
            if (!vl[i] && d > slk[i]) d = slk[i];
        }
        for (int i = 1; i <= n; i++) {
   
            if (vl[i])
                hl[i] += d;
            else
                slk[i] -= d;
            if (vr[i]) hr[i] -= d;
        }
        for (int i = 1; i <= n; i++)
            if (!vl[i] && !slk[i] && !check(i)) return;
    }
}

LL KM() {
   
    for (int i = 1; i <= n; i++) fl[i] = fr[i] = -1, hr[i] = 0;  // 初始化标杆:左标杆fl,右标杆fr
    for (int i = 1; i <= n; i++) hl[i] = *max_element(g[i] + 1, g[i] + n + 1);  // 一开始左标杆的值
    for (int j = 1; j <= n; j++) bfs(j);  // O(n^3)的bfs解法
    LL re = 0;
    for (int i = 1; i <= n; i++)
        if (g[i][fl[i]])
            re += g[i][fl[i]];
        else
            fl[i] = 0;
    return re;
}

int main() {
   
    while (scanf("%d", &n) != EOF) {
   
/* 如果是求最小权值的最优匹配，这里建图要这样初始化
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= n; ++j) 
                g[i][j] = -INF;
*/
        for (int i = 1; i <= n; ++i)  // 读入任意两个点的权值关系
            for (int j = 1; j <= n; ++j) scanf("%lld", &g[i][j]);
        // 如果是求最小权值的最优匹配，那么这里g[i][j] = -g[i][j]
        LL ans = KM();
        printf("%lld\n", ans);  // 如果是求最小权值的最优匹配,这里ans = -ans
    }
    return 0;
}

2.4 二分图多重匹配

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXN = 1010;
int st[MAXN], g[MAXN][MAXN], n, m;

struct NODE {
   
    int cnt;
    int matchs[MAXN];
} match[MAXN];

bool dfs_solve(int x, int limit) {
   
    for (int i = 1; i <= m; ++i) {
     // 枚举右部图的每个点
        if (!st[i] && g[x][i]) {
   
            st[i] = 1;
            if (match[i].cnt < limit) {
     // 如果当前点的匹配数目小于limit，那么直接匹配。如果每个点能够匹配的数目不同，那么这里使用num[i](替代limit)表示右部图第i个点能够匹配的点数目
                match[i].matchs[++match[i].cnt] = x;
                return 1;
            }
            for (int j = 1; j <= match[i].cnt; j++) {
     // 如果当前点的匹配数目等于limit
                if (dfs_solve(match[i].matchs[j], limit)) {
     // 那么让当前所匹配的点去匹配其他点
                    match[i].matchs[j] = x;
                    return 1;
                }
            }
        }
    }
    return 0;
}

int hungary(int limit) {
     // 多重匹配的最大匹配
    int res = 0;
    memset(match, 0, sizeof(match));
    for (int i = 1; i <= n; ++i) {
   
        memset(st, 0, sizeof(st));
        if (dfs_solve(i, limit)) res++;  // 这里还可以优化，改为if (!dfs_solve(i, l, r)) return 0;意思为如果当前这个点没有找到匹配点，那么则不可能找到使得左部图每个点都匹配。
    }
    return res;  // 如果40行采用优化写法，这个改为：return 1;
}

int main() {
   
    while (scanf("%d%d", &n, &m) != EOF) {
最低0.47元/天 解锁文章
「已注销」
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
专题十 匹配问题
m0_49959202的博客
12-25 441
文章目录专题十 匹配问题HDU - 1045 Fire NetHDU 2444 The Accomodation of StudentsHDU 1083 CoursesHDU - 1281 棋盘游戏HDU-2819 SwapHDU-2389 Rain on your ParadeHDU - 4185 Oil SkimmingPOJ - 3020 Antenna PlacementHDU - 1054 Strategic GameHDU - 1151 Air RaidPOJ - 2594 Treasure E
最佳匹配问题
qq_37955484的博客
10-27 3131
最佳匹配是我们经常会遇到的问题，我们通常使用匈牙利算法或KM算法解决这类问题。这类问题离不开权值的比较，也就是我们最爱举的例子——男女最佳匹配中的某个男孩更爱某个女孩的具体数值了。这里我找了个大神的讲解，非常通俗易懂，具体如下。 点击这里 我们可以这么理解，第一次，男生都向最喜欢的告白，女生当然只能接受数值最高那个啦，但这只是暂时的。第二次男生吸取教训，被拒绝的男生把拒接他的女生的名字从名单中去掉...
9. 匹配问题
Debroon
06-13 1683
二分图匹配 文章目录二分图匹配最大匹配与完全匹配最大流算法匈牙利基于DFS基于BFS   最大匹配与完全匹配   最大流算法   匈牙利   基于DFS   基于BFS ...
匹配问题总结
08-12 288
1.二分图 二分图概念，二分图判定(dfs,bfs染色),二分图最大匹配(匈牙利算法(O(M*N)）,Hopcroft-Karp算法(O(sqrt(n)*m))，最小点覆盖，最大独立集 二分图相关参考博客：https://www.cnblogs.com/czsharecode/p/9777533.html 对匈牙利算法以及HK算法解析：https://www.cnblogs.com...
正则表达式学习
qq_39225271的博客
09-16 330
正则表达式[ABC][^ABC][A-Z].[\s\S]\w$()*+?\^{|{n}{n,}{n,m}\b\B\d\D\f\n\r\t\v\W [ABC] 匹配字符串的ABC [^ABC] 匹配除了ABC的所有字符 [A-Z] 匹配大写字母，[a-z]表示匹配小写字母，[0-9]表示匹配数字 . 匹配主力换行符之外的任何单个字符，即[^\n\r] [\s\S] 匹配所有，\s表示所有空白符，包括换行 \S表示非空白符，包含换行 \w 匹配字母数字下划线，即[A-Za-z0-9_] $ 匹配输入字符串的结尾
括号匹配问题
11-09
完整代码，可运行出结果，利用栈进行括号匹配
数据结构的括号匹配问题
09-28
数据结构的括号匹配问题是一个经典的计算机科学议题，主要涉及字符串处理、递归算法和栈数据结构的应用。在编程领域，括号匹配是确保代码逻辑正确性的重要手段，尤其是在解析数学表达式、编译器设计以及XML/JSON等...
三维匹配问题是NP完全的
01-07
【三维匹配问题】 给定三个不相交的集合X、Y、Z，三个集合的大小都为n。给定一个三元组集合T⊆X×Y×ZT \subseteq X \times Y \times ZT⊆X×Y×Z，集合T的大小为m。 问：T中是否存在一个大小为n的子集T’，这个子集...
近似串匹配问题 动态规划法——C++代码
06-08
通过阅读和理解这段代码，你可以更深入地了解动态规划法如何应用于近似串匹配问题，并掌握如何在C++环境中编写此类算法。不过，请注意，虽然这个代码可能适用于作业场景，但在实际项目中，我们通常会要求更高效的...
过匹配问题解决
ai543064193的博客
05-29 726
种减轻过匹配的其他的方法：L1 规范化、dropout 和人工增加训练样本。Dropout ：Dropout 是一种相当激进的技术。和 L1、L2 规范化不同，dropout 并不依赖对代价函数的变更。而是，在 dropout 中，我们改变了网络本身。让我在给出为何工作的原理之前描述一下 dropout 基本的工作机制和所得到的结果。假设我们尝试训练一个网络：特别地，假设我们有一个训练数据 和 对...
概率论经典问题之匹配问题
pdcxs007的专栏
10-23 3万+
一个屋子里面有N个人，每个人有一顶帽子。假如所有人把帽子扔到屋子中央，然后每个人都随机选一顶帽子。 a) 没有人捡到自己帽子的概率； b) 有k(k⩽N)k(k \leqslant N)个人捡到自己帽子的概率。
一款社交教育类问答游戏的在线匹配问题
hengxuan2176的博客
12-31 267
背景：一款Android应用《么么答》 问题：1.如何判断玩家是否在线？ ·           2.如果有两个以上的玩家在线，应该怎样匹配？                       ①匹配的逻辑代码写在web服务器的servlet里吗？                       ②匹配的过程需要重启一个线程吗？                       ③匹配的思路大概是什
匹配问题学习小结(POJ)
fobdddf的专栏
05-29 746
临行上海，决定把最近研究过的各种匹配题做个汇总，原因是这样既可以巩固自己对匹配问题的掌握，又可以借此复习一下匹配问题的各种外在表现形式。我认为，如果比赛中出到匹配，出题者在问题的算法上大做文章的可能性不大，大多数出题者一定会挖空心思来设计一个让你眼花缭乱的背景，借此来隐藏匹配问题的实质！ 二分图最小覆盖的Konig定理及其证明 二分图： 顶点可以分类两个集合X和Y，所有的
推断统计学-假设检验-匹配样本的假设检验的理解
sinat_35238412的博客
10-29 1587
推断统计学-假设检验-匹配样本的假设检验的理解
图的匹配问题相关模板
平凡人Kalzn的博客
05-15 325
基本二分图匹配匈牙利算法和一些基本的定理不再阐述 必经\可行点，必经\可行点 必经可行边在这里可以看到。 可行点：同可行边，所有可行边连接的点，都是可行点，否则不是可行点。 必经点：除暴力枚举外，我们在跑完网络流的残留图上枚举所有的未匹配点，进行dfs，记录所有历经点，所有没有被历经的点，都是必经点。（因为每个点每条边最多经历一边，所以dfs复杂度是O(n+m) ） ...
多对一 单向关联 匹配 关系数据库中的外键参照关系
jylovejava
10-20 519
多对一 单向关联 匹配 关系数据库中的外键参照关系 2008-09-06 12:22 映射 多对一 单向关联 [原创 2007-02-07 15:14:44]    读完 Java对象持久化技术详解6.1节，写一下读书笔记：     多对一 单向关联 匹配 关系数据库中的外键参照关系。      在关系数据库中，只存在外键参照关系，而且是由many---&gt;...
稳定匹配问题（一）
cxy的博客
12-06 5300
稳定匹配问题（一） 经典稳定匹配问题--Gale-Shapley算法[1] 1. 算法描述 算法特点：延迟决定、产生的结果有偏向性 举例说明：  man  woman              woman   man             1：A  B  C                    A： 2  1  3             2：B  A  C
Stable Matching Problem稳定匹配问题-----稳定婚姻算法
热门推荐
cscmaker的专栏
12-13 3万+
（一）问题的引出：             有N男N女，每个人都按照他对异性的喜欢程度排名。现在需要写出一个算法安排这N个男的、N个女的结婚，要求两个人的婚姻应该是稳定的。             何为稳定？             有两对夫妻M1 F2，M2 F1。M1心目中更喜欢F1，但是他和F2结婚了，M2心目中更喜欢F2，但是命运却让他和F1结婚了，显然这样的婚姻是不稳定的，随时都可
matlab双边匹配问题
最新发布
09-09
您好！对于双边匹配问题，Matlab提供了一个内置函数 `matchFeatures` 来执行双边特征匹配。这个函数可以用于在两个图像之间进行特征匹配，并返回匹配的特征点。 您可以使用以下语法来调用 `matchFeatures` 函数： ```matlab indexPairs = matchFeatures(features1, features2) [indexPairs, matchMetric] = matchFeatures(features1, features2) [indexPairs, matchMetric, matchInfo] = matchFeatures(features1, features2) ``` 其中，`features1` 和 `features2` 是两个特征描述子矩阵，可以使用 `extractFeatures` 函数从图像中提取得到。`indexPairs` 是一个 Mx2 矩阵，每一行代表一对匹配的特征点的索引。 如果需要，您还可以获取匹配的度量（match metric）和其他匹配信息。请注意，`matchFeatures` 函数默认使用归一化八点法（normalized eight-point algorithm）进行匹配。 希望这能帮到您！如果还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值