安全プランを証明する：（法律、貪欲法、動的計画法を見つけるために）ロープを切ります

1.タイトル説明

/ * 
タイトル説明は
　　あなたの長さnの文字列を与える、Mカットしてくださいロープ部分（M、nは整数であり、nは> 1およびM> 1）、各ロープの長さをkと呼ばれている[0]、 kは[1]、...、kは [m]を。[0] XK [1] k個ます X ... XK [m]の最大の可能な製品はどのくらいですか？ロープの長さ8:00である場合、例えば、現時点で得られた生成物2,3,3は最大18である三つのセクションの長さにカット。
入力説明：
　　番号を入力します。nは、問題の表面の意味を参照してください。（2 <= N <= 60 ） 

実施例1 
入力8 
出力18 
* /

 

コード1：貪欲アルゴリズム（最も簡単）

考え

/ ** 
 *タイトルの分析：
 *最初のいくつかの例を見ることにするルール。
 * 4：2 * 2 
 * 5：2 * 3 
 * 6：3 * 3 
 * 7：2×2×3または4×3 
 ×8：2 * 3 * 3 
 * 9：3 * 3 * 3 
 * 10：2 * 2 * 3 * 3または4 * 3 * 3 
 * 11：2 * 3 * 3 * 3 
 * 12：3 * 3 * 3 * 3 
 * 13 * 3 2 * 2 * 3 * 3 * 3または4 * 3 3 * 
 * 
 *下記の分析である：
 *最初のkを決定する[0]がデジタルであってもよい[m]をkに、実際には、わずか2または3であることができます。
 *もちろん、4があるかもしれませんが、4 = 2 * 2、私たちは、単にそれらにそれらを考慮していない人。
 * 5 <2 * 3,6 <* 3 3、私たちも考えられ、我々は分裂し続けなければならない必要はありません数6より大きい。
 *第二に、数2は確かに3未満である、数2と3を見て、なぜですか？2 * 2 * 2 <3 * 3ので、そのタイトルはシンプルです。
 * 3 Nで割っ直接残りはラインか上の2つまたは2 2 2から判断されます。
 M> 1から所定*タイトル、それは、唯一の直接バックライン上のこれらの2つの特別なケースのみ2 * 1 * 1 2 3です。
 * 
 *コンピューティングパワーの複雑さがある：O（n個のログを記録）、ダイナミックプログラミングに時間のかかる多くを行うことであろう。
 * /

できるだけ多くみましょう3

コード

輸入 java.utilの。* ;
パブリック クラスソリューション{
     公共 静的 ボイドメイン（文字列[]引数）{ 
        スキャナSC = 新しいスキャナ（System.in）。
        INT、N = sc.nextInt（）。
        cutRope（N）
        
    } 
    パブリック 静的 INT cutRope（INT ターゲット）{
         場合（ターゲット== 2 ）{
             返す 1 。
        } 
        であれば（ターゲット== 3 ）{
             戻り 2 。
        } 
        int型NUM3 =ターゲット/ 3 。
        int型からnum2 = 0 ;
         スイッチ（ターゲット％3 ）{
             ケース 0：破ります。
            ケース 1 ：{ 
                NUM3 = num3-1 。
                NUM2 = 2 。
                破ります; 
            } 
            ケース 2 ：{ 
                NUM2 = 1 。
                破ります; 
            }   
        } 
        リターン（INT）（Math.pow（2、NUM2）* Math.pow（3 、NUM3））。
    } 
}

 

コード2：動的計画

アイデア：

 @ダイナミックプログラミング：iは、利用可能な最大の長さの積：DP [i]はDPを= [J] * DP [IJ]最大

インポート java.utilのクラス*。;
 パブリック クラスソリューション{
     公共 静的 ボイドメイン（文字列[]引数）{ 
        スキャナSC = 新しい新しいスキャナ（System.in）;
         int型 N- = sc.nextInt（）; 
        cutRope（N-）; 
        
    } 
    // 動的プログラミング：iが利用可能な最大長さの積：DP [I] = DP [ J] * DP [IJ] 最大
    パブリック 静的 INT cutRope（INT N-）{
        // N - <= 3の場合、M> 1これは、セグメント化されなければならない
        IF - （== 2 N ）
             リターン 1。;
         IF（N - == 3 ）
             リターン2 ;
         int型 [] DP = 新しい新しい INT [N- + 1]; // iが利用可能な場合、最大製品長
        
        DP [ = 1。] ; 
        DPは、[ 2] = 2 ; 
        DP [ 3] = 3 ;
         INT RES = 0; //は最大を記録
        するための（int型 {; I <= N-I ++はI = 4）// 注4境界と
            のために（INT J = 1。; J <= I / 2、J ++ ）{
                 // 動的プログラミング：生成物Iの使用可能な最大長さ：DP [i]はDP [= J] * DP [IJ] 最大 
                RES = Math.max（RES、DP [J] * [ijのDP ;]）
            } 
            DPを[I]= RES。
        } 
        戻りDP [n]は、
    } 
}