99久久精品国产一区二区蜜芽 ,久久精品成人免费网站,国产一区二区久久久

Floyd_Warshall��法

lzmagic — Fri, 10 Apr 2009 19:14:00 GMT

/**
* FLOYD_WARSHALL 所有顶点对的最短�\径算�?nbsp;(All-Pairs Shortest Path Algorithm)
* 输入�Q�图g
* 输出�Q�所有顶点对的最短�\径长
* �l�构�Q�图g用邻接矩阵表�C?br> * ��法�Q�Floyd_Warshall��法(动态规�?
* 复杂度：O(|V|^3)
*/
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <stack>
#include <queue>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <functional>
#include <climits>
using namespace std;

int n;
vector<vector<int> > g;
vector<vector<int> > dist;

void Floyd_Warshall()
{
    // 初始化dist�Q�顶炚w��(无中间顶�?最短�\径长��长，��点到自�w�的最短�\径长�?�?nbsp;
    dist = g;
    for (int i = 0; i < n; ++i)
        dist[i][i] = 0;
    // 从顶点i到定点j且中间顶点皆属于集合{0, 1, 2, , k}的最短�\径长�?nbsp;
    for (int k = 0; k < n; ++k)
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                if (dist[i][k] < INT_MAX && dist[k][j] < INT_MAX)
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}

int main()
{
    n = 5;
    g.assign(n, vector<int>(n, INT_MAX));
    g[0][1] = 3; g[0][2] = 8; g[0][4] = -4;
    g[1][3] = 1; g[1][4] = 7;
    g[2][1] = 4;
    g[3][0] = 2; g[3][2] = -5;
    g[4][3] = 6;

    Floyd_Warshall();

    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
            cout << dist[i][j] << ' ';
        cout << endl;
    }

    system("pause");
    return 0;
}

lzmagic 2009-04-11 03:14 发表评论

Kruskal��法

lzmagic — Fri, 10 Apr 2009 11:41:00 GMT

/**
* KRUSKAL 最��生成树��法 (Minimum Spanning Tree)
* 输入�Q�图g�Q?nbsp;                // 有向图或者无向图
* 输出�Q?1)最��生成树长sum�Q?nbsp;
*         (2)最��生成树mst�?br> * �l�构: 图g用顶�Ҏ��n和边集edges(优先队列)表示�Q�两�Ҏ��否连通用�q�查集实现�?nbsp;
* ��法�Q�Kruskal��法
* 复杂度：O(|E|*log|E|)~O(|E|*log|V|)
*/
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <functional>
#include <climits>
using namespace std;

struct Edge
{
    int u, v, w;        // u、v:两个��点  w:�?nbsp;
    Edge() { }
    Edge(int u0, int v0, int w0):u(u0), v(v0), w(w0) { }
};

int n;                    // n : ��点个数
vector<Edge> edges;        // edges : 图g的所有边
int sum;                // sum : 最��生成树�?nbsp;
vector<Edge> mst;        // mst : 最��生成树(用边集表�C?

class DisjSets
{
    vector<int> s;
    public:
        DisjSets(int n) : s(n, -1) { };
        int find (int x)
        {
            if (s[x] < 0) return x;
            else return s[x] = find(s[x]);   // 压羃路径�?nbsp;
        };
        void unionSets(int root1, int root2)
        {
            if (s[root1] > s[root2])    // 按个数求�q?个数用负数表�C?�?nbsp;
            {
                s[root2] += s[root1];
                s[root1] = root2;
            }
            else
            {
                s[root1] += s[root2];
                s[root2] = root1;
            }
        };
};

bool Cmp(const Edge &lhs, const Edge &rhs)
{
    return lhs.w > rhs.w;
}

bool Kruskal()
{
    DisjSets ds(n);
    make_heap(edges.begin(), edges.end(), Cmp);    // 对边集徏堆�?nbsp;
    int root1, root2;
    Edge e;
    while (!edges.empty())    // 遍历所有边�Q?nbsp;
    {
        e = edges.front(); pop_heap(edges.begin(), edges.end(), Cmp); edges.pop_back();// 从未选边集中��L��最��权的边e�?nbsp;
        root1 = ds.find(e.u), root2 = ds.find(e.v);    // 获取u、v所在的炚w��Q?nbsp;
        if (root1 != root2)                // 如果u、v不是同一个点集，
        {
            sum += e.w;                 // 调整最��生成树�?nbsp;
            mst.push_back(e);             // 把边e攑օ�最��生成树mst中，
            ds.unionSets(root1, root2);    // 合�ƈ两点所在的炚w��?nbsp;
        }
        if (mst.size() == n - 1) return true; // 如果选取边个��Cؓn - 1�Q�成功�?/span>
    }
    return false;
}

int main()
{
    n = 7;
    edges.clear();
    edges.push_back(Edge(0, 1, 2)); edges.push_back(Edge(0, 2, 4));  edges.push_back(Edge(0, 3, 1));
    edges.push_back(Edge(1, 3, 3)); edges.push_back(Edge(1, 4, 10));
     edges.push_back(Edge(2, 3, 2)); edges.push_back(Edge(2, 5, 5));
     edges.push_back(Edge(3, 4, 7)); edges.push_back(Edge(3, 5, 8)); edges.push_back(Edge(3, 6, 4));
     edges.push_back(Edge(4, 6, 6));
     edges.push_back(Edge(5, 6, 1));

     sum = 0;
     mst.clear();
     if(Kruskal())
     {
        cout << sum << endl;
        for (vector<Edge>::iterator it = mst.begin(); it != mst.end(); ++it)
            cout << it->u << "->" << it->v << endl;
    }
    else
    {
        cout << "Some vertex cann't be reached." << endl;
    }

    system("pause");
    return 0;
}

lzmagic 2009-04-10 19:41 发表评论

Prim��法

lzmagic — Fri, 10 Apr 2009 11:11:00 GMT

/**
* PRIM(��单版) 最��生成树��法 (Minimum Spanning Tree)
* 输入�Q�图g�Q?nbsp;                // 有向图或者无向图
* 输出�Q?1)最��生成树长sum�Q?nbsp;
*         (2)最��生成树prev�?br> * �l�构: 图g用邻接矩阵表�C�，最短边长dist用数�l�表�C��?nbsp;
* ��法�Q�Prim��法
* 复杂度：O(|V|^2)
*/
#include <iostream>
#include <vector>
#include <list>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <functional>
#include <climits>
using namespace std;

int n;                    // n : ��点个数
vector<vector<int> > g; // g : �?graph)(用邻接矩�?adjacent matrix)表示)
vector<bool> known;        // known : 各点是否已经选取
vector<int> dist;        // dist : 已选取炚w��到未选取点的最��边�?nbsp;
vector<int> prev;        // prev : 最��生成树中各点的前一��点
int s;                    // s : ��L��(start)
int sum;                // sum : 最��生成树�?nbsp;

bool Prim()                // 贪心��法(Greedy Algorithm)
{
    known.assign(n, false);
    dist.assign(n, INT_MAX);
    prev.resize(n);            // 初始化known、dist、prev�?nbsp;
    dist[s] = 0;            // 初始化�v点到自��n的�\径长�?�?/span>
    int i;
    for (i = 0; i < n; ++i)
    {
        int min = INT_MAX, v;
        for (int i = 0; i < n; ++i)
            if (!known[i] && min > dist[i])
                min = dist[i], v = i;    // ��L��未知的最短�\径长的顶点v�Q?nbsp;
        if (min == INT_MAX) break;        // 如果找不刎ͼ�退出；
        known[v] = true;                // 如果扑ֈ��Q�将��点v设�ؓ已知�Q?/span>
        sum += dist[v];                 // 调整最��生成树�?nbsp;
        for (int w = 0; w < n; ++w)        // 遍历所有v指向的顶点w�Q?nbsp;
            if (!known[w] && g[v][w] < INT_MAX && dist[w] > g[v][w])
                dist[w] = g[v][w], prev[w] = v;    // 调整��点w的最短�\径长dist和最短�\径的前一��点 prev�?nbsp;
    }
    return i == n; // 如果选取��点个数为n�Q�成功�?nbsp;
}

int main()
{
    n = 7;
    g.assign(n, vector<int>(n, INT_MAX));
    g[0][1] = g[1][0] = 2; g[0][2] = g[2][0] = 4;   g[0][3] = g[3][0] = 1;
    g[1][3] = g[3][1] = 3; g[1][4] = g[4][1] = 10;
    g[2][3] = g[3][2] = 2; g[2][5] = g[5][2] = 5;
    g[3][4] = g[4][3] = 7; g[3][5] = g[5][3] = 8; g[3][6] = g[6][3] = 4;
    g[4][6] = g[6][4] = 6;
    g[5][6] = g[6][5] = 1;

    s = 0;        // ��L��任�?nbsp;
    sum = 0;
    if (Prim())
    {
        cout << sum << endl;
        for (int i = 1; i < n; ++i)
            if(i != s) cout << prev[i] << "->" << i << endl;
    }
    else
    {
        cout << "Some vertex cann't be reached." << endl;
    }

    system("pause");
    return 0;
}

lzmagic 2009-04-10 19:11 发表评论

Critical Path 关键路径

lzmagic — Thu, 09 Apr 2009 15:02:00 GMT

摘要: /**//** * CRITICALPATH(��单版) 关键路径 * 输入�Q�无环图g�?nbsp; * 输出�Q?1)各点最早完成时间ec�Q?nbsp; * (2)各点最晚完成时间lc�Q?nbsp; * &n... 阅读全文

lzmagic 2009-04-09 23:02 发表评论

Bellman_Ford��法 SPFA��法

lzmagic — Thu, 09 Apr 2009 11:16:00 GMT

摘要: /**//** * BELLMAN_FORD (��单版) 单源最短�\径算法（允许存在负边�Q?nbsp; * 输入�Q?1)有向图g�Q?nbsp;* (2)源点s�?nbsp; * 输出�Q?1)源点s到各点的最短�\径长... 阅读全文

lzmagic 2009-04-09 19:16 发表评论

Dijkstra��法

lzmagic — Thu, 09 Apr 2009 02:45:00 GMT

/**
* DIJKSTRA(��单版) 单源最短�\径算法（不允许存在负边）
* 输入�Q?1)图g�Q?nbsp;       // 有向图或者无向图
*         (2)源点s�?nbsp;
* 输出�Q?1)源点s到各点的最短�\径长dist�Q?nbsp;
*         (2)源点s到各点的最短�\径prev�?br> * �l�构: 图g用邻接矩阵表�C�，最短�\径长dist用数�l�表�C��?nbsp;
* ��法�Q�Dijkstra��法
* 复杂度：O(|V|^2)
*/
#include <iostream>
#include <vector>
#include <list>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <functional>
#include <climits>
using namespace std;

int n;                    // n : ��点个数
vector<vector<int> > g; // g : �?graph)(用邻接矩�?adjacent matrix)表示)
int s;                    // s : 源点(source)
vector<bool> known;        // known : 各点是否知道最短�\�?nbsp;
vector<int> dist;        // dist : 源点s到各点的最短�\径长
vector<int> prev;        // prev : 各点最短�\径的前一��点

void Dijkstra()            // 贪心��法(Greedy Algorithm)
{
    known.assign(n, false);
    dist.assign(n, INT_MAX);
    prev.resize(n);            // 初始化known、dist、prev�?nbsp;
    dist[s] = 0;            // 初始化源点s到自�w�的路径长�ؓ0�?nbsp;
    for (;;)
    {
        int min = INT_MAX, v = s;
        for (int i = 0; i < n; ++i)
            if (!known[i] && min > dist[i])
                min = dist[i], v = i;    // ��L��未知的最短�\径长的顶点v�Q?nbsp;
        if (min == INT_MAX) break;        // 如果找不刎ͼ�退出；
        known[v] = true;                // 如果扑ֈ��Q�将��点v设�ؓ已知�Q?nbsp;
        for (int w = 0; w < n; ++w)        // 遍历所有v指向的顶点w�Q?nbsp;
            if (!known[w] && g[v][w] < INT_MAX && dist[w] > dist[v] + g[v][w])
                dist[w] = dist[v] + g[v][w], prev[w] = v;    // 调整��点w的最短�\径长dist和最短�\径的前一��点 prev�?nbsp;
    }
}

void Print_SP(int v)
{
     if (v != s) Print_SP(prev[v]);
     cout << v << " ";
}

int main()
{
    n = 7;
    g.assign(n, vector<int>(n, INT_MAX));
    g[0][1] = 2; g[0][3] = 1;
    g[1][3] = 3; g[1][4] = 10;
    g[2][0] = 4; g[2][5] = 5;
    g[3][2] = 2; g[3][4] = 2; g[3][5] = 8; g[3][6] = 4;
    g[4][6] = 6;
    g[6][5] = 1;

    s = 0;
    Dijkstra();

    copy(dist.begin(), dist.end(), ostream_iterator<int>(cout, " ")); cout << endl;
    for (int i = 0; i < n; ++i)
        if(dist[i] != INT_MAX)
        {
            cout << s << "->" << i << ": ";
            Print_SP(i);
            cout << endl;
        }

    system("pause");
    return 0;
}

lzmagic 2009-04-09 10:45 发表评论

lzmagic — Thu, 09 Apr 2009 02:44:00 GMT

/**
* USP 无权最短�\径算�?Unweighted Shortest Path Algorithm)
* 输入�Q?1)图g�Q?nbsp;       // 有向图或者无向图
*         (2)源点s�?nbsp;
* 输出�Q?1)源点s到各点的无权最短�\径长dist(路径的边数最��?�Q?nbsp;
*         (2)源点s到各点的无权最短�\径prev�?nbsp;
* �l�构: 图g用邻接表表示�Q�最短�\径长dist用数�l�表�C��?nbsp;
* ��法�Q�广度优先搜�?BFS)
* 复杂度：O(|E|+|V|)~O(|E|)
*/
#include <iostream>
#include <vector>
#include <list>
#include <queue>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <functional>
#include <climits>
using namespace std;

int n;                        // n : ��点个数
vector<list<int> > g;        // g : �?graph)(用邻接表(adjacent list)表示)
int s;                        // s : 源点(source)
vector<int> dist;            // dist : 源点s到各点之间的距离
vector<int> prev;            // prev : 各点最短�\径的前一��点�?nbsp;

void USP()        // �q�度优先搜烦(BFS)
{
    queue<int> que;
    dist.assign(n, INT_MAX);                     // 初始化dist�Q?nbsp;
    prev.resize(n);                                // 初始化prev�?nbsp;
    dist[s] = 0; que.push(s);                    // s到自�w�距��Mؓ0�Q�s入队�?nbsp;
    while (!que.empty())
    {
        int v = que.front(); que.pop();            // v出队�Q?nbsp;
        for (list<int>::iterator it = g[v].begin(); it != g[v].end(); ++it) // 遍历v盔R��?it�Q?nbsp;
            if (dist[*it] == INT_MAX)            // 如果*it未访问，
            {
                dist[*it] = dist[v] + 1; prev[*it] = v;    // 调整�?it�Q?nbsp;
                que.push(*it);                    // *it入队�?nbsp;
            }
    }
}

void Print_SP(int v)
{
     if (v != s) Print_SP(prev[v]);
     cout << v << " ";
}

int main()
{
    n = 7;
    g.assign(n, list<int>());
    g[0].push_back(1); g[0].push_back(3);
    g[1].push_back(3); g[1].push_back(4);
    g[2].push_back(0); g[2].push_back(5);
    g[3].push_back(2); g[3].push_back(4); g[3].push_back(5); g[3].push_back(6);
    g[4].push_back(6);
    g[6].push_back(5);

    s = 2;
    USP();

    copy(dist.begin(), dist.end(), ostream_iterator<int>(cout, " ")); cout << endl;
    for (int i = 0; i < n; ++i)
        if(dist[i] != INT_MAX)
        {
            cout << s << "->" << i << ": ";
            Print_SP(i);
            cout << endl;
        }

    system("pause");
    return 0;
}

lzmagic 2009-04-09 10:44 发表评论

Topsort 拓扑排序

lzmagic — Mon, 06 Apr 2009 01:40:00 GMT

/**
* TOPSORT(��单版) 拓扑排序(Topological Sort)
* 输入�Q�有向图g
* 输出�Q�是否存在拓扑排序，如果存在�Q�获取拓扑排序序列seq
* �l�构�Q�图g用邻接矩阵表�C?br> * ��法�Q�广度优先搜�?BFS)
* 复杂度：O(|V|^2)
*/

#include <iostream>
#include <vector>
#include <queue>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <climits>
using namespace std;

int n;                            // n �Q�顶点个�?nbsp;
vector<vector<int> > g;           // g �Q�图(graph)(用邻接矩�?adjacent matrix)表示)
vector<int> seq;                // seq �Q�拓扑序�?sequence)

bool TopSort()
{
    vector<int> inc(n, 0);
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
             if (g[i][j] < INT_MAX) ++inc[j]; // 计算每个��点的入度，
    queue<int> que;
    for (int j = 0; j < n; ++j)
        if (inc[j] == 0) que.push(j); // 如果��点的入度�ؓ0�Q�入队�?/span>
    int seqc = 0;
    seq.resize(n);
    while (!que.empty())     // 如果队列que非空�Q?/span>
    {
        int v = que.front(); que.pop();
        seq[seqc++] = v;      // ��点v出队�Q�放入seq中，
        for (int w = 0; w < n; ++w)     // 遍历所有v指向的顶点w�Q?/span>
            if (g[v][w] < INT_MAX)
                if (--inc[w] == 0) que.push(w); // 调整w的入度，如果w的入度�ؓ0�Q�入队�?nbsp;
    }
    return seqc == n; // 如果seq已处理顶�Ҏ��为n�Q�存在拓扑排序，否则存在回�\�?/span>
}

int main()
{
    n = 7;
    g.assign(n, vector<int>(n, INT_MAX));
    g[0][1] = 1, g[0][2] = 1, g[0][3] = 1;
    g[1][3] = 1, g[1][4] = 1;
    g[2][5] = 1;
    g[3][2] = 1, g[3][5] = 1, g[3][6] = 1;
    g[4][3] = 1, g[4][6] = 1;
    g[6][5] = 1;

    if (TopSort())
    {
         copy(seq.begin(), seq.end(), ostream_iterator<int>(cout, " "));
         cout << endl;
    }
    else
    {
         cout << "circles exist" << endl;
    }

    system("pause");
    return 0;
}

lzmagic 2009-04-06 09:40 发表评论

(正则表达�?是否匚w��(字符�?

lzmagic — Sat, 04 Apr 2009 14:58:00 GMT

/**
* IS_MATCHED
* 输入�Q?1)一个正则表辑ּ��Q�带有正则符�?*'�?+'�??'�?.'(正则�W�号不相�?�Q?nbsp;
*          '*'�Q��Q意多个�Q意字�W�；
*          '+'�Q�至��?个�Q意字�W�；
*          '?'�Q?个或1个�Q意字�W�；
*          '.'�Q�恰�?个�Q意字�W��?nbsp;
*       (2)一个字�W�串�?nbsp;
* 输出�Q�该正则表达式是否匹配该字符�?nbsp;
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

bool Is_Matched(string &reg, string &str)
{
     bool is_asterisk, is_plus, is_question, is_dot, is_ok(true);
     string substr;
     string::iterator reg_it(reg.begin()), str_it(str.begin()), str_it2;
     while (is_ok && reg_it != reg.end())
     {
         // 分离正则�W�号�l�is_asterisk、is_plus、is_question、is_dot�?nbsp;
         is_asterisk = *reg_it == '*';
         is_plus     = *reg_it == '+';
         is_question = *reg_it == '?';
         is_dot      = *reg_it == '.';
         if ( is_asterisk || is_plus || is_question || is_dot) ++reg_it;
         // 分离子字�W�串�l�substr�?nbsp;
         substr.clear();
         for (reg_it = reg_it; reg_it != reg.end()
                           && *reg_it != '*'
                           && *reg_it != '+'
                           && *reg_it != '?'
                           && *reg_it != '.'; ++reg_it)// 调整reg_it�?nbsp;
             substr.push_back(*reg_it);
         // 匚w��子字�W�串�Q�substr�I�，str_it2=>end()�Q�否则str_it2=>匚w��Ҏ��end()�?nbsp;
         if (substr.empty()) str_it2 = str.end();
         else str_it2 = search(str_it, str.end(), substr.begin(), substr.end());
         // 是否匚w��正则�W�号�Q�is_asterisk不做判断�?nbsp;
         if (is_plus     && str_it ==  str_it2
          || is_question && str_it != str_it2 && str_it != str_it2 - 1
          || is_dot      && str_it != str_it2 - 1) is_ok = false;
         // 是否匚w��子字�W�串�?nbsp;
         if (!substr.empty() && str_it2 == str.end()) is_ok = false;
         else str_it = str_it2 + substr.size();       // 调整str_it�?nbsp;
     }
     // 匚w��成功�Q�is_ok为true�Q�reg_it到达reg.end()�Q�str_it到达str.end()�?nbsp;
     return is_ok && reg_it == reg.end() && str_it == str.end();
}

int main ()
{
    string reg, str; // input : *l?m.g+ lzmagic ?zm lzmagic
    while (cin >> reg >> str)
    {
          if (Is_Matched(reg, str)) cout << "match" << endl;
          else cout << "dismatch" << endl;
    }

    system("pause");
    return 0;
}

lzmagic 2009-04-04 22:58 发表评论

lzmagic — Fri, 03 Apr 2009 01:53:00 GMT

/**
* QUICKSORT : sort
*        void sort(iterator beg, iterator end);
*        void sort(iterator beg, iterator end, compare cmp);
*/
#include <iostream>
#include <iterator>
#include <algorithm>
#include <numeric>
using namespace std;

int Partition(int *a, int lhs, int rhs)
{
       int key = a[rhs];
       int i = lhs - 1;
       for (int j = lhs; j < rhs; ++j)
             if (a[j] <= key) swap(a[++i], a[j]);
       swap(a[++i], a[rhs]);
       return i;
}

void QuickSort(int *a, int lhs, int rhs)
{
      if (lhs < rhs)
      {
             int mid = Partition(a, lhs, rhs);
             QuickSort(a, lhs, mid - 1);
             QuickSort(a, mid + 1, rhs);
      }
}

int main()
{
    int a[100];
    for (int i = 0; i < 100; ++i) a[i] = i;
    random_shuffle(a, a + 100);
    copy(a, a + 100, ostream_iterator<int>(cout, " ")); cout << endl << endl;

    QuickSort(a, 0, 99);
    copy(a, a + 100, ostream_iterator<int>(cout, " ")); cout << endl;

    system("pause");
    return 0;
}

lzmagic 2009-04-03 09:53 发表评论

99久久精品国产一区二区蜜芽 ,久久精品成人免费网站,国产一区二区久久久

Floyd_Warshall���法

Kruskal���法

Prim���法