POJ - 3469デュアルコアCPU（最小カット）

紹介することを目的と質問

コアAのいずれかを実行し、コアBは、デュアルコアCPUで構成されているNのタスク、タスクA iは、コア上で実行される愛をとり、Bは、コア上で行わ、Biのようにとり、二つのタスクにデータとの間に必要とされてもよいです2つのタスクが同じコア上で実行されている場合は、データ交換が反映されませんインタラクティブ、異なるコア上で実行された場合、コストのwiを生成し、生成する最小コストのすべてを実行するために、n個のタスクを尋ねます。

問題解決のためのアイデア

トピック要件N Nタスクは、我々は一般的に最小の労力で最小カット問題、即ち、二つの部分にn個の点に変換する最小の総コスト、そのようなトピックを実行するように2つの異なるセットに割り当てられたタスク。次のように建設計画は次のとおりです。

ソース側を構築する能力によって、各タスクに1）愛

2）シンク側を構築するために、各タスクの容量バイあります

3）同一の2つのコアのタスク、Bで実行されていない、Wは、追加の費用をもたらすであろう、我々は、A-> B、B->に分割され、A、B、W間の2つの辺の容量を構築しA

最後に、我々は最小カットを実行し、図の建設に最小出力にカット。

コードエリア

書式#include <iostreamの> 
の#include <cstdioを> 
する#include <アルゴリズム> 
書式#include <CStringの> 
の#include <キュー> 
の#include < 文字列 > 
の#include <fstreamの> 
の#include <ベクトル> 
の#include <スタック> 
の#include <マップ> 
書式#include <iomanip>

#defineバグCOUT << "**********" << ENDL
 の#defineショー（X、Y）COUT << "[" << X <<」、 "<< Y <<"] "
 の#define LOCAL = 1。
使用して 名前空間はstdを、
typedefの長い 長いLL。
const  int型 INF = 0x3f3f3f3f 。
CONST LL MOD = 1E9 + 7 。
const  int型マックス= 4E6 + 10 。

構造体のエッジ
{
    int型、流れ、次へ。
}エッジ[最大 << 1 ]。

INTのN、M、S、T。
int型のヘッド[最大]、TOT;
INT DIS [最大]、cur変換[マックス]。

無効のinit（）
{
    memsetの（頭、 - 1、はsizeof （ヘッド））。= 0 ;
    S = 0 。
    T = N + 1 。
}

無効アドオン（int型のu、int型の V、int型の流れ）
{
    EDGE [TOT] .TO = V？
    エッジ【TOT] .flow = 流量;
    エッジ【TOT] .next = 頭部[U]。
    ヘッド[U]は ++ TOTを= 。
}

BOOL BFS（）
{
    memset（DIS、 - 1、はsizeof （DIS））。
    キュー < 整数 > Q;
    DIS [S] = 0 ;
    q.push（S）;
    しばらく（！q.empty（））
    {
        INT U = q.front（）。
        q.pop（）;
        用（int型！; - I = I =ヘッド[U] 1 ; I = エッジ[I] .next）
        {
            int型 V = エッジ[I] .TO。
            もし（エッジ[I] .flow> 0 && DIS [V] == - 1 ）
            {
                DIS [V] = DIS [U] + 1 。
                もし（V == t）が
                     復帰 真。
                q.push（V）;
            }
        }
    }
    返す 偽;
}

int型 DFS（int型のu、int型flow_in）
{
    もし（uは== t）が
         戻りflow_in。
    int型 flow_out = 0 ;
    用（int型 ;！ - I = I = CUR [U] 1 ; I = [I] .nextエッジ）
    {
        cur変換[U] = I。
        int型 V = エッジ[I] .TO。
        もし（DIS [V] == DIS [U] + 1 &&エッジ[I] .flow> 0 ）
        {
            INTの流れ= DFS（V、分（flow_in、エッジ[I] .flow））。
            もし（流れが== 0 ）
                 続けます。
            flow_in - = 流れ。
            flow_out + = 流量;
            エッジ[I] .flow - = 流量;
            エッジ[I ^ 1 ] .flow + = 流;
            もし（flow_in == 0 ）
                 ブレーク。
        }
    }
    返すflow_out;
}

int型 Dinic（INT 年）
{
    int型の合計= 0 ;
    しばらく（BFS（））
    {
        以下のために（int型私= 0 ; I <= ANS;私は++ ）
            cur変換[I] = 頭部[I]。
        和 + = DFS（S、INF）。
    }
    戻り値の合計。
}

int型のmain（）
{
LOCALの#ifdef
    // freopenは（ "INPUT.TXT"、 "R"、STDIN）。
    // freopenは（ "output.txtと"、 "W"、STDOUT）; 
#endifの
    一方（のscanf（" ％d個の％のD "、＆N、＆M）！= EOF）
    {
        その中に（）;
        用（int型 i = 1 ; iが<= N; iが++、B ）
        {
            scanf関数（" ％D％dの"、＆、＆B）。
            追加（S、I、A）;
            追加（I、S、0 ）;
            追加（I、T、B）。
            追加（T、I、0 ）;
        }
        用（int型 I = 1、U、V、流れ; I <= M; iは++ ）
        {
            scanf関数（" ％D％D％D "、およびuは、＆V、＆フロー）;
            （U、V、フロー）を追加します。
            （V、U、フロー）を追加します。
        }
        printf（" ％d個の\ n "、Dinic（N + 1 ））。
    }
    リターン 0 ;
}

コードの表示