最大フロー問題--FFとDinicアルゴリズム

// algorithm_FF.cpp：このファイルは、「メイン」機能が含まれています。プログラムの実行が開始され、ここで終了します。
//

の#include "pch.h"

の#include <iostreamの>
の#include <SET>
書式#include <math.h>の
書式#include <アルゴリズム>

//マックスストリームFFアルゴリズム
//行列表現

の#define INF INT_MAX

// N＃はDEFINE 5

INT Dの[5] [5] = {{0,4,6、INF、INF}、
               {INF、0,2、3、INF}、
               {INF、INF、0、INF ,. 4}、
           {INF、 INF、INF、0 ,. 5}、
           {INF、INF、INF、INF、0;}}

。の#define 6 N
[6] [6] int型のC = {{0,8,12、INF、INF、INF}
               INF {0、INF、6,10、INF}、
               {INF、2,0,10、INF、INF}、
           {INF、INF、INF、0、INF ,. 8}、
           {INF、INF、INF、
           INF {、INF、INF、INF、INF、0}};

構造体{エッジ
   INT C;
   INT F;
};
エッジエッジ[N]、[N]は、

フラグにINT [N]; //各点がマークされている
INT PREVノードの前にある; // [N]
INTデルタ[N];ノンストップ分（分（すべて（CF2））、分（F_））の最小値に// J
INTカテナalberghiera [N]; //

空隙init_edge（INTマット[] [N ]）// 第二次元は、マークを開始
{
   （; Iは、Nを<I ++はI = 0をINT）ため
   、{
       ため（INT J = 0; J <N; J ++）
       {
           IF（MAT ！[I] [J] = 0及びMAT [I] [J] <INF）
           {
               エッジ[I] [J] .C = MAT [I]、[J]、
               エッジ[I] [J] = 0 .F ;
           }
       }

   }

}

のconst int型S = 0; //変更された理由
INT 5 T =定数;

//使用して名前空間STD;

FF（）無効
{

   （1）一方
   {
       memsetの（FLAG、0xFFで、（）フラグにはsizeofでの）; // // -1に設定基準は、基準1であるかどうかを示します。、参照番号0チェックしないように、番号1を参照チェックする
       のmemset（PREV、0xffで、はsizeof（ PREV））; // //は-1に設定
       のmemset（デルタ、0xFFで、はsizeof（デルタ））; //セット- 1
       フラグ[S] = 0で; //
       PREV [S] = 0;
       デルタ[S] = INF;
       INT edge_head = -1;デルタの//、大文字ブック三角形の
       INT edge_tail = 0;
       カテナalberghiera [edge_tail] = Sを、

       一方、（edge_head <edge_tail）//最初の時間0 <1; 1,3 // BFS検索
       {
           edge_head ++; //初めて1。
           INT Iは、
           Iが=カテナalberghiera [edge_head]; //最初の時刻s 、5,5 @ 4,4 @ 3,3 @ 2,2 @ 0,1,1 .. / 4,3 //ノード
           （INT 1 = J。; J <N; J ++）用
           {
               IF（フラグに[J] == -1）//標識されていないレポーター
               {
                   IF（エッジ[I] [J] .C <INFとエッジ[I] [J] .F <エッジ[I ] [J] .C）// アバットメントと不飽和
                   {
                       フラグ[J] = 0で、
                       PREV [J] = I;
                       デルタ[J] STD :: =分（デルタ[I ]、エッジ[I] [J] .C -エッジ[I] [J]。F.）、
                       カテナalberghiera [edge_tail ++] = J; //最初の時間edge_tail = 2、チェーン[2] = 1; / / II：// 3,2は、ここでメモリリークを改善

                   }
                   他IF（エッジ[J] [I] .C <INFとエッジ[J] [I] .F> 0）//
                   {
                       フラグに[J] = 0;
                       PREV [J] = -i。
                       デルタ[J] STD :: =分（デルタ[I]、エッジ[J] [I] .F）;
                       カテナalberghiera [edge_tail ++] = J; //
                   }

               }
           }
           フラグに[I] = 1; //表しますこれは、処理されましたか？？？？わからない

       }

       （デルタフラグ== 0で[T]又は[T] == -1）//デルタ[T] = 0が示す場合に飽和していない鎖、すなわち開始点を増強見つけることができない、フラグ[T ] = - 1（符号がチェックされていない）、即ち、増強経路の不在フラグではない、ではないTに、中断表す
           ブレーク; //エンド
       int型のT = K1;
       INT KO = ABS（PREV [K1] ）;
       INT = Aデルタ[T];
       。一方、（1）バック//
       {
           IF（エッジ[KO] [K1] .C <INF）
               エッジ[KO] [K1] .F + = A;
           他[エッジ（IF K1] [KO] .C <INF）
               エッジ[K1] [KO] .F - = A。
           もし（K0 == S）
               ブレーク。
           K1 = K0;
           K0 = ABS（PREV [K1]）。
       }
       デルタ[T] = 0; //新一轮开始

   }

   INT F = 0。

   用（INTのJ = 1、J <N; J ++）
   {
       IF（エッジ[S] [J] .F <INF）
           {
               F + =エッジ[S] [J] .F。
           }
   }

   のstd :: COUT << "maxflow" << F <<はstd :: ENDL。

}

int型のmain（）
{
   int型F = 0。
   init_edge（C）。
   FF（）;

   std :: coutの<< "Hello Worldの\ nは！";
}

/ *

の#include <ベクトル>
の#include <アルゴリズム>

#define INF 2E9
名前空間stdを使用。
I、J、K、N、M、H、T、TOT、ANS、ST、EN int型。
構造体ノード{
   int型のC、F。
}エッジ[MAXN] [MAXN]。
INTフラグ[MAXN]、プリ[MAXN]、アルファ[MAXN]、Q [MAXN]、V。
読み取りINT（）{
   チャーC。int型のx; 一方、（C = GETCHAR（）、C < '0' || C> '9'）。X = C - '0'。
   一方、（C = GETCHAR（）、C> = '0' && C <= '9'）、X = X * 10 + C - '0'。Xを返します。

}

//两个例子1 // 6 9 1 6 1 2 8 1 3 12 2 4 6 2 5 10 3 2 2 3 4 10 4 6 8 5 4 2 5 6 10
// 2 // 5 6 1 5 1 2 4 1 3 6 2 3 2 2 4 3 3 5 4 4 5 5つの

ボイドBFS（）{
   memsetの（FLAG、0xffで、はsizeof（フラグ））。memsetの（前、0xffで、はsizeof（PRE））。memset（アルファ、0xffで、はsizeof（アルファ））。
   フラグ[ST]は= 0。[ST]は= 0の事前。アルファ[ST] = INF。H = 0、T = 1。Q [T] = ST。
   一方で（H <T）{
       H ++。V = Q [H]。
       以下のために（INT i = 1; iは= N <; iは++）{
           IF（フラグ[i]が== -1）{
               IF（エッジ[V] [I] .C <INF &&エッジ[V] [I] .F <エッジ[V] [I] .C）{
                   フラグ[I] = 0; 事前[I] = V。アルファ[i]は=分（アルファ[V]、エッジ[V] [I] .C -エッジ[V] [I] .F）。Q [++ T] = I。
               }
               そうであれば（エッジ[I] [V] .C <INF &&エッジ[I] [V] .F> 0）{
                   フラグ[I] = 0; 事前[I] = -v。アルファ[i]は=分（アルファ[V]、エッジ[I] [V] .F）。Q [++ T] = I。
               }
           }
       }
       フラグ[V] = 1。
   }
}

ボイドFord_Fulkerson（）{
   （1）{一方
       BFS（）。
       IF（アルファ[EN] == 0 ||フラグ[EN] == -1）{
           破ります。
       }
       int型K1 = EN、K2 = ABS（予備[K1]）。INT A =アルファ[EN]。
       一方、（1）{
           IF（エッジ[K2] [K1] .C <INF）エッジ[K2] [K1] .F + = A。
           そうでなければ（エッジ[K1] [K2] .C <INF）エッジ[K1] [K2] .F場合- =。
           もし（K2 == ST）ブレーク。
           K1 = K2; K2 = ABS（予備[K1]）。
       }
       アルファ[EN] = 0;
   }
}

ボイドフロー（）{
   int型maxflow = 0。
   以下のために（INT i = 1; iが<= N; I ++）
       のための（INT J = 1; J <= nであり、j ++）{
           IF（I == ST &&エッジ[I] [J] .F <INF）maxflow + =エッジ[I] [J] .F。
       }
   のprintf（ "％のD"、MaxFlow）;
}

int型のmain（）{
   int型U、V、C、F;
   N- =読む（）; M =読む（）; ST =読む（）; EN =読みます（）。
   用（INT I = 1; I <= N; I ++）
       のための（INT J = 1; J <= N; J ++）エッジ[I] [J] .C = INF、エッジ[I] [J] .F = 0;
   のための（INT I = 1; I <= M; I ++）{
       U =読む（）; V =読む（）; C =読む（）;
       エッジ[U] [V] .C = C;
   }
   Ford_Fulkerson（）;
   フロー（）;
   0を返す;
}
* /

//プログラムを実行します。Ctrlキー+ F5またはデバッグ> "開始（ないデバッグ）"メニュー
//デバッガ：F5またはデバッグ> "デバッグ開始"メニュー

開始するための//ヒントを：
// 1.追加/管理するためのソリューションエクスプローラ]ウィンドウを使用してファイル
のチームエクスプローラ]ウィンドウを使用して// 2.ソース管理に接続されている
// 3.生成された出力と、他のメッセージを表示するために、出力ウィンドウを使用します
// 4.エラー表示するには、エラー一覧]ウィンドウ
「プロジェクト」>新しいコードファイルを作成するには、「新しいアイテムを追加」、または「プロジェクト」に行くことに// 5. [>を既存のコードに「既存項目の追加」プロジェクトにファイルを追加し
、プロジェクトを再度開き、「ファイル」>「開く」>「プロジェクト」に移動しての.slnファイルを選択するために、// 6.未来

最大フロー問題--FFとDinicアルゴリズム

おすすめ