羅区-P3389-ガウス消去

トピックリンクします。https：//www.luogu.org/problem/P3389

質問の意味：ソリューションの複数のセットは、ユニークなソリューション、出力ユニークな解決策がある場合はいかなる解決策は、存在しないと入力すると、あなたの方程式を与えます。

 

 例えば、上記の式は、どのようにコンピュータでそれを行うには？

ガウス消去アルゴリズムの説明：ギャングスターは記事それを見て、私よりも良い書き込み、一般的な考え方は、マトリックスの変更の決定要因です。最後に、三角形状にレディース兄の盗難を決定基

 

 式の右辺の最後の列は、列の図の正面の値が変換された係数が最後の行では、唯一の要因を見つけることができるされ、可変得られた溶液の最後の行は、最後から二番目の行は、唯一の要件の変数があります。

ギャングのブログのアドレス：

https://45475.blog.luogu.org/linear-equation-group

輸入java.io.BufferedReader; 
インポートのjava.io.File; 
輸入java.io.FileInputStream; 
インポートにjava.io.IOException; 
輸入java.io.InputStreamを。
輸入java.io.InputStreamReader。
インポートjava.util.Scanner; 
輸入java.util.StringTokenizer。

パブリック クラスメイン
{ 
    静的スキャナスキャナ。

    静的 INT N = 110 。
    // 静的int型N = 5; 

    静的 ダブル [] [] = 新しい ダブル[N]、[N]。
    静的 ダブル []結果= 新しい ダブル[N]。

    静的 int型N; 

    パブリック 静的 ボイドのinit（）
    { 
        ため（int型 i = 0 ; iがNを<; iは++ ）
        { 
            ための（int型 J = 0 ; J <N; J ++ ）
            { 
                [I] [J] = 0 ; 
            } 
            をもたらす[I] = 0 ; 
        } 
    } 

    パブリック 静的 ボイドメイン（文字列[]引数）は、IOExceptionがスロー
    { 
        入力ストリームに =システム。に;
        // =新しいFileInputStreamを（新しいファイル（ "D：でのInputStream // 1.text"））; 
        Reader.init（中）
        N = Reader.nextInt（）。
        // Reader.next（）; 
        以下のために（int型 i = 0 ; iがn <I ++は）
        { 
            ための（int型 J = 0 ; J <= nであり、j ++ ）
            { 
                [I] [J] = Reader.nextInt（）を。
            } 
        } 

        // 高斯消元算法
        ため（INT C = 0; C <N - 1。C ++ ）
        { 
            int型 MAXR = C。
            // 寻找最大值的行
            のための（int型 I = MAXR + 1 ; iは<N; iは++ ）
            { 
                場合（Math.abs（[I] [C]）を> Math.abs（[MAXR] [C]） ）
                { 
                    MAXR = I。
                } 
            } 
            もし（MAXR =！C）
            { 
                swapRow（MAXR、C、N + 1 ）。
                MAXR = C。
            }
            ダンプ（）;
             // [MAXR] [C]が0に等しいチェック
            IF（[MAXR] [C] == 0 ）
            { 
                BREAK ; 
            } 
            ため（INT R＆LT = C + 1 ; R＆LT <N-; R＆LT ++ ）
            { 
                // [R]を分析[C] 0かどうかである
                場合（[R] [C] == 0 ）
                { 
                    // 現在の列が0に等しくなった場合、何の除去が
                    続行しない; 
                } 
                // 現在の行の各々について減数開始
                ダブル valは= [MAXR] [C] / [R＆LT] [C]を、
                 ため（INT C2 = C; <= N-C2、C2 ++）
                { 
                    [R] [C2] [R] [C2] *ヴァル= - [MAXR] [C2]を。
                } 
            } 
            ）（ダンプ。
        } 

        // 判断是否无解
        INT溶液= 1 。
        用（int型 iは= 0 ; iがN <I ++の）
             場合（（[I] [I] == 0 && [I] [N] =！0）||（[I] [I] == 0 && [i]は[N] == 0 ））
            { 
                溶液 = 0 。
                破ります;
            } 
        もし（溶液== 0 ）
        { 
            システム。アウト .println（" ノーソリューション" ）; 
        } 
        他
        { 
            // 求解
            INT K = 0 。
            以下のために（int型 I = N - 1 ; I> = 0 ; i-- ）
            { 
                二重合計= 0 ;
                用（INT J = 0 ; J <K、J ++ ）
                { 
                    合計 + =結果[N - J -1 ] * [I] [N - J - 1 ]。
                } 
                場合（[i]が[N - 1 - K] == 0 ）
                { 
                    [i]をもたらす = 1 。
                } 
                他
                { 
                    結果[I] =（[I] [N] -合計）/ [I] [N - 1 - K]。
                } 

                K ++ 。
            } 
            のために（int型 i = 0 ; iがn <; iは++ ） 
            {
                システム。アウト .printf（" ％.2fの\ nは" 、結果[I]）。
            } 
        } 
    } 

    静的 ボイドダンプ（）
    { 
//         ため（INT i = 0; iがn <; iは++）
 //         {
 //             ため（INT J = 0であり、j <= nであり、j ++）
 //             {
 //                 システム。 out.print（」 "+ [I] [J]）。
//             }
 //             のSystem.out.println（）;
//         }
 //         のSystem.out.println（）;
//         のSystem.out.println（）; 
    } 

    静的 ボイド swapRow（int型I、int型 J、int型N）
    { 
        ため（INT C = 0 ; C <N; C ++ ）
        { 
            ダブル T = [J] [C]。
            [J] [C] = [I]を[C]。
            [I] [C] = Tと、
        } 
    } 

    静的 クラスリーダー
    { 
        静的BufferedReaderのリーダー。
        静的StringTokenizerはトークナイザ。

        / * *入力ストリームリーダを初期化するためにこのメソッドを呼び出す* / 
        静的 ボイドINIT（入力ストリーム入力）
        { 
            リーダー = 新しい BufferedReaderの（新しいInputStreamReaderの（入力））。
            トークナイザ = 新 StringTokenizerは（"" ）; 
        } 

        / * *次の単語を取得* / 
        静的スロー）（次の文字列にIOException 
        { 
            ながら（！tokenizer.hasMoreTokens（））
            { 
                文字列S = reader.readLine（）。
                もし（S == nullの）リターンの。
                トークナイザ= 新しいStringTokenizerは（S）。
            } 
            を返す）（tokenizer.nextTokenします。
        } 

        静的 INT nextInt（）はIOExceptionがスロー
        { 
            返すInteger.parseIntを（次の（））。
        } 

        静的 ダブルnextDouble（）はIOExceptionがスロー
        { 
            返すDouble.parseDouble（次の（））。
        } 
    } 
}