Problem:
苗木
植物学者のサトー博士は苗木用の特殊肥料を何種類も発明しました。その肥料を苗木に与えると、瞬く間に苗木の大きさが変わります。
 但し、肥料に以下のように副作用があることが判明しました。
1 回目に与えた肥料だけでは、苗木の大きさが変わりません。
2 回目以降は、その回に与えた肥料と、その直前に与えた肥料との組み合わせによって苗木に影響を与えます。良い影響を与えると苗木が伸び、悪い影響を与えると苗木が縮んでしまうこともあります。
試しに、サトー博士は 3 種類の肥料 (肥料 1、2、3) に対し、ある時点で与えた肥料 (今回の肥料) とその直前に与えた肥料 (直前の肥料) の組み合わせによる苗木の成長度合いを調べ、以下の「成長度表」を作成しました。
右表の 1 行目は今回与える肥料の番号で、1 列目はその直前に与えた肥料の番号です。他の数字は直前に与えた肥料と今回与える肥料の組み合わせによる苗木の成長度 (成長後対成長前の大きさの比率) を示します。成長度 > 1.0 の場合は苗木が伸びる、成長度 < 1.0 の場合は苗木が縮むことを示します。例えば肥料 1 の後に肥料 2 を与えると苗木の大きさが 3 倍になるが、肥料 1 の後に肥料 3 を与えると苗木の大きさが半分に縮んでしまいます。
苗木に与える肥料の回数が制限された場合、苗木をできるだけ大きく育てるにはどの肥料をどのような順で与えればよいでしょうか?「成長度表」がその答え教えてくれます。例として上の表にある肥料を 3 回だけ与える場合、以下のように肥料 3 → 肥料 1 → 肥料 2 の順にあげると最も苗木が成長します。
1 回目の肥料 (肥料 3) では苗木の大きさは変わりません。
2 回目の肥料 (肥料 1) では、表より肥料 3 後の肥料 1 での成長度が 3.0 なので、苗木の大きさは前回の 3.0 倍になります。
3 回目の肥料 (肥料 2) では、表より肥料 1 後の肥料 2 での成長度が 3.0 なので、苗木の大きさはさらに前回の 3.0 倍で、最初の 3.0 × 3.0 の 9.0 倍になります。
今度は、サトー博士は発明した
n
種類の肥料を全部調べて、上のような「成長度表」を作りあげましたが、非常に大きな表になってしまい、肥料の種類と与える順番を決めるのに大変苦労しています。
そこで博士に代わり、
n
種類の肥料の組み合わせによる苗木の「成長度表」中の成長度値部分を入力とし、肥料を
m
回与えた後の最大の苗木の大きさを求めるプログラムを作成してください。ただし、初めの苗木の大きさを 1 とし、1 回目に与える肥料の成長度はどの肥料でも 1.0 とします。なお、肥料は 1 から
n
まで番号付けされています。
Input
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。 各データセットは以下の形式で与えられます。
n
m
g
11
g
12
...
g
1n
g
21
g
22
...
g
2n
:
g
n1
g
n2
...
g
nn
1 行目に肥料の種類数
n
(2 ≤
n
≤ 100)、 肥料を与える回数
m
(1 ≤
m
≤ 100) が与えられます。
続く
n
行に、肥料
i
の後に肥料
j
を与えた時の苗木の成長度
g
ij
(0.0 ≤
g
ij
≤ 10.0, 実数) が与えられます。
データセットの数は 20 を超えません。
Output
データセット毎に、最大の苗木の大きさを１行に出力します。出力する苗木の大きさは、小数点第 3 位を四捨五入して、小数点第 2 位まで求めてください。
Sample Input
3 3          
1.3 3.0 0.5 
2.4 2.1 1.0
3.0 0.8 1.2
2 2
1.0 1.0
1.0 1.0
0 0
Output for the Sample Input
9.00
1.00

Submitted solutions:

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];
double solve(int times, int prev) {
  if (times == m)
    return dp[times][prev] = 1;
  if (dp[times][prev] != -1)
    return dp[times][prev];
  double tmp = -1;
  for (int i = 0; i < n; i++) {
    if (times == 0) {
      tmp = max(tmp, solve(times + 1, i) * 1);
    } else {
      tmp = max(tmp, solve(times + 1, i) * t[prev][i]);
    }
  }
  return dp[times][prev] = tmp;
}
int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    int ret;
    double retd;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3380
final_rank: 9

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];
double solve(int times, int prev) {
  if (dp[times][prev] != -1)
    return dp[times][prev];
  if (times == m)
    return dp[times][prev] = 1;
  double tmp = -1;
  // Move the condition check outside the loop
  if (times == 0) {
    for (int i = 0; i < n; i++) {
      tmp = max(tmp, solve(times + 1, i));
    }
  } else {
    for (int i = 0; i < n; i++) {
      tmp = max(tmp, solve(times + 1, i) * t[prev][i]);
    }
  }
  return dp[times][prev] = tmp;
}
int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    int ret;
    double retd;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3328
final_rank: 3

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;

const int MAX_N = 101;

int n, m;
double dp[MAX_N][MAX_N];
double t[MAX_N][MAX_N];

double solve(int times, int prev) {
  // Check if the probability has already been calculated
  if (dp[times][prev] >= 0)
    return dp[times][prev];

  // Base case: reach the maximum number of steps
  if (times == m)
    return dp[times][prev] = 1;

  double maxProb = -1;
  for (int i = 0; i < n; i++) {
    double prob;
    if (times == 0) {
      prob = solve(times + 1, i) * 1;
    } else {
      prob = solve(times + 1, i) * t[prev][i];
    }
    maxProb = max(maxProb, prob);
  }

  // Store the calculated probability in the dp array for future use
  return dp[times][prev] = maxProb;
}

int main(void) {
  while (cin >> n >> m) {
    if (n == 0 && m == 0)
      break;

    // Initialize only the portion of the dp array that is used
    for (int i = 0; i <= m; i++) {
      for (int j = 0; j < n; j++) {
        dp[i][j] = -1;
      }
    }

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }

    double maxProb = solve(0, 0) * 100;
    printf("%.2lf\n", round(maxProb) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3456
final_rank: 12

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;

const int MAX_N = 101;

int n, m;
double dp[MAX_N][MAX_N];
double t[MAX_N][MAX_N];

double calculate(int n, int m) {
  double dp[MAX_N][MAX_N];
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      dp[i][j] = -1;
    }
  }

  for (int times = m; times >= 0; times--) {
    for (int prev = 0; prev < n; prev++) {
      if (times == m) {
        dp[times][prev] = 1;
      } else {
        double tmp = -1;
        for (int i = 0; i < n; i++) {
          if (times == 0) {
            tmp = max(tmp, dp[times + 1][i] * 1);
          } else {
            tmp = max(tmp, dp[times + 1][i] * t[prev][i]);
          }
        }
        dp[times][prev] = tmp;
      }
    }
  }

  return dp[0][0];
}

int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    double result = calculate(n, m) * 100;
    printf("%.2lf\n", round(result) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3296
final_rank: 2

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;

int n, m;
double** dp;
double** t;

double solve(int times, int prev) {
  if (dp[times][prev] != -1)
    return dp[times][prev];

  if (times == m)
    return dp[times][prev] = 1;

  double tmp = -1;

  if (times == 0) {
    for (int i = 0; i < n; i++) {
      tmp = max(tmp, solve(times + 1, i) * 1);
    }
  } else {
    for (int i = 0; i < n; i++) {
      tmp = max(tmp, solve(times + 1, i) * t[prev][i]);
    }
  }

  return dp[times][prev] = tmp;
}

int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;

    // Allocate memory for dp and t arrays
    dp = new double*[m + 1];
    t = new double*[n];
    for (int i = 0; i <= m; i++) {
      dp[i] = new double[n];
      fill(dp[i], dp[i] + n, -1);
    }
    for (int i = 0; i < n; i++) {
      t[i] = new double[n];
    }

    int ret;
    double retd;

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }

    retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);

    // Free memory for dp and t arrays
    for (int i = 0; i <= m; i++) {
      delete[] dp[i];
    }
    delete[] dp;
    for (int i = 0; i < n; i++) {
      delete[] t[i];
    }
    delete[] t;
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3368
final_rank: 8

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>

using namespace std;

int n, m;
double dp[101][101];
double t[101][101];

double solve(unsigned short int times, unsigned short int prev) {
  if (dp[times][prev] != -1)
    return dp[times][prev];
  if (times == m)
    return dp[times][prev] = 1;
  double max_val = -1.0, tmp;
  for (unsigned short int i = 0; i < n; i++) {
    if (times == 0) {
      tmp = solve(times + 1, i);
    } else {
      tmp = solve(times + 1, i) * t[prev][i];
    }
    max_val = max(max_val, tmp);
  }
  return dp[times][prev] = max_val;
}

int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    double retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3328
final_rank: 3

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <map>
#include <cmath>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <numeric>
#include <functional>

using namespace std;
using ll = long long;

void solve(int n, int m){
    vector<vector<double>> g(n, vector<double>(n));
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cin >> g[i][j];

    vector<vector<double>> dp(m + 1, vector<double>(n, -1e6));
    for (int i = 0; i < n; i++)dp[0][i] = 0;
    for (int i = 0; i < n; i++)dp[1][i] = 1;

    for (int i = 1; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < n; k++) {
                dp[i + 1][j] = max(dp[i + 1][j], dp[i][k] * g[k][j]);
            }
        }
    }

    double ans = 0;
    for (int i = 0; i < n; i++) {
        ans = max(ans, dp[m][i]);
    }
    printf("%.2f\n",ans);
}
int main() {
    while(true){
        int n,m;
        cin >> n >> m;
        if(n == 0 && m == 0)break;
        solve(n,m);
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3588
final_rank: 17

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <map>
#include <cmath>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <numeric>
#include <functional>

using namespace std;
using ll = long long;

int main() {
    while (true) {
        int n, m;
        cin >> n >> m;
        if (n == 0 && m == 0)break;
        vector<vector<double>> g(n, vector<double>(n));
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                cin >> g[i][j];

        vector<vector<double>> dp(m + 1, vector<double>(n, -1e6));
        for (int i = 0; i < n; i++)dp[0][i] = 0;
        for (int i = 0; i < n; i++)dp[1][i] = 1;

        for (int i = 1; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    dp[i + 1][j] = max(dp[i + 1][j], dp[i][k] * g[k][j]);
                }
            }
        }

        double ans = 0;
        for (int i = 0; i < n; i++) {
            ans = max(ans, dp[m][i]);
        }
        printf("%.2f\n",ans);
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3632
final_rank: 19

code_snippet: #include<bits/stdc++.h>
using namespace std;
int main()
{
    while(true)
	{
		int N,M;cin>>N>>M;
		if(N==0)return 0;
		vector<vector<double>>A(N,vector<double>(N));
		for(int i=0;i<N;i++)for(int j=0;j<N;j++)cin>>A[i][j];
		vector<vector<double>>dp(M+1,vector<double>(N,0));
		for(int i=0;i<N;i++)dp[1][i]=1;
		for(int i=2;i<=M;i++)
		{
			for(int j=0;j<N;j++)
			{
				for(int k=0;k<N;k++)
				{
					dp[i][j]=max(dp[i][j],dp[i-1][k]*A[j][k]);
				}
			}
		}
		cout<<fixed<<setprecision(2);
		cout<<*max_element(dp[M].begin(),dp[M].end())<<endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 3668
final_rank: 20

code_snippet: #include<bits/stdc++.h>
using namespace std;
int main()
{
    while(true)
	{
		int N,M;cin>>N>>M;
		if(N==0)return 0;
		vector<vector<double>>A(N,vector<double>(N));
		for(int i=0;i<N;i++)for(int j=0;j<N;j++)cin>>A[i][j];
		vector<vector<double>>dp(M+1,vector<double>(N,0));
		for(int i=0;i<N;i++)dp[1][i]=1;
		for(int i=2;i<=M;i++)
		{
			for(int j=0;j<N;j++)
			{
				for(int k=0;k<N;k++)
				{
					dp[i][j]=max(dp[i][j],dp[i-1][k]*A[k][j]);
				}
			}
		}
		cout<<fixed<<setprecision(2);
		cout<<*max_element(dp[M].begin(),dp[M].end())<<endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 3600
final_rank: 18

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
using namespace std;
int main()
{
    while(true)
	{
		int N,M;cin>>N>>M;
		if(N==0)return 0;
		vector<vector<double> >A(N,vector<double>(N));
		for(int i=0;i<N;i++)for(int j=0;j<N;j++)cin>>A[i][j];
		vector<vector<double> >dp(M+1,vector<double>(N,0));
		for(int i=0;i<N;i++)dp[1][i]=1;
		for(int i=2;i<=M;i++)
		{
			for(int j=0;j<N;j++)
			{
				for(int k=0;k<N;k++)
				{
					dp[i][j]=max(dp[i][j],dp[i-1][k]*A[k][j]);
				}
			}
		}
		cout<<fixed<<setprecision(2);
		cout<<*max_element(dp[M].begin(),dp[M].end())<<endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 3504
final_rank: 15

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];

double solve(int times, int prev) {
  if (dp[times][prev] > -0.5)
    return dp[times][prev];
  if (times == m)
    return dp[times][prev] = 1;
  double tmp = 0;
  for (int i = 0; i < n; i++) {
    tmp = max(tmp, solve(times + 1, i) * (times == 0 ? 1 : t[prev][i]));
  }
  return dp[times][prev] = tmp;
}

int main(void) {
  while (cin >> n >> m && (n || m)) {
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    double retd;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3360
final_rank: 6

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];

double solve(int times, int prev) {
  if (dp[times][prev] > -0.5)
    return dp[times][prev];
  if (times == m)
    return dp[times][prev] = 1;
  double tmp = 0;
  for (int i = 0; i < n; i++) {
    tmp = max(tmp, solve(times + 1, i) * (times ? t[prev][i] : 1));
  }
  return dp[times][prev] = tmp;
}

int main(void) {
  while (cin >> n >> m && (n || m)) {
    fill(*dp, *dp + 101 * 101, -1);
    int ret;
    double retd;
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
        cin >> t[i][j];
    retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3404
final_rank: 10

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];

double solve(int times, int prev) {
  if (times == m)
    return dp[times][prev] = 1;
  if (dp[times][prev] != -1)
    return dp[times][prev];
  
  double tmp = -1;
  for (int i = 0; i < n; i++) {
    double cost = (times == 0) ? 1 : t[prev][i];
    tmp = max(tmp, solve(times + 1, i) * cost);
  }
  return dp[times][prev] = tmp;
}
int main(void) {
  while (cin >> n >> m, n | m) {
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
        cin >> t[i][j];
    
    double result = solve(0, 0) * 100;
    printf("%.2lf\n", round(result) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3404
final_rank: 10

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];

double solve(int times, int prev) {
  if (times == m) return 1;
  if (dp[times][prev] != -1) return dp[times][prev];
  
  double tmp = -1;
  for (int i = 0; i < n; i++) {
    tmp = max(tmp, solve(times + 1, i) * (times == 0 ? 1 : t[prev][i]));
  }

  return dp[times][prev] = tmp;
}

int main(void) {
  while (cin >> n >> m && (n | m)) {
    fill(&dp[0][0], &dp[0][0] + sizeof(dp) / sizeof(double), -1);
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }

    double retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3360
final_rank: 6

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];
double solve(int times, int prev) {
  if (dp[times][prev] != -1)
    return dp[times][prev];
  if (times == m)
    return dp[times][prev] = 1;
  double tmp = -1;
  for (int i = 0; i < n; i++) {
    if (times == 0) {
      tmp = max(tmp, solve(times + 1, i) * 1);
    } else {
      tmp = max(tmp, solve(times + 1, i) * t[prev][i]);
    }
  }
  return dp[times][prev] = tmp;
}
int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    int ret;
    double retd;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3484
final_rank: 14

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];
double solve(int times, int prev) {
  if (dp[times][prev] != -1)
    return dp[times][prev];
  if (times == m)
    return dp[times][prev] = 1;
  double tmp = -1;
  for (int i = 0; i < n; i++) {
    if (times == 0) {
      tmp = max(tmp, solve(times + 1, i) * 1);
    } else {
      tmp = max(tmp, solve(times + 1, i) * t[prev][i]);
    }
  }
  return dp[times][prev] = tmp;
}
int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    double ret;
    double retd;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    retd = solve(0, 0) * 100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3468
final_rank: 13

code_snippet: #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int n, m;
double dp[101][101];
double t[101][101];
double solve(int times, int prev) {
  if (dp[times][prev] != -1)
    return dp[times][prev];
  if (times == m)
    return dp[times][prev] = 1;
  double tmp = -1;
  for (int i = 0; i < n; i++) {
    if (times == 0) {
      tmp = max(tmp, solve(times + 1, i) * 1);
    } else if (dp[times + 1][i] != -1){
      tmp = max(tmp, dp[times + 1][i] * t[prev][i]);
    } else {
      tmp = max(tmp, solve(times + 1, i) * t[prev][i]);
    }
  }
  return dp[times][prev] = tmp;
}
int main(void) {
  while (cin >> n >> m) {
    if (!(n | m))
      break;
    fill((double *)dp, (double *)dp + 101 * 101, -1);
    int ret;
    double retd;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        cin >> t[i][j];
      }
    }
    for(int i=m-1;i>=0;--i){
      for(int j=0;j<n;++j){
        solve(i,j);
      }
    }
    retd = dp[0][0]*100;
    printf("%.2lf\n", round(retd) / 100);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3348
final_rank: 5

code_snippet: #include<bits/stdc++.h>
using namespace std;
int n, m;
double g[110][110], memo[110][110];
double dp(int mae, int sum){
    if(sum == 0) return 1.0;
    if(memo[mae][sum]>0) return memo[mae][sum];
    double res = 0.0;
    for(int i=1;i<=n;i++){
        res = max(res, dp(i, sum-1)*g[mae][i]);
    }
    return memo[mae][sum] = res;
}
int main(){
    while(cin >> n >> m, n!=0){
        for(int i=1;i<=n;i++) g[0][i] = 1.0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++) cin >> g[i][j];
        }
        fill_n(*memo, 110*110, 0.0);
        printf("%.2f\n", dp(0, m));
    }
    return(0);
}
accuracy: 1
time_ms: 10
memory_kb: 3264
final_rank: 1

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll = long long;

int main(){
    int n, m;
    while(cin >> n >> m, n){
        vector<vector<double>> A(n, vector<double>(n)), dp(m, vector<double>(n));
        for(int y = 0; y < n; y++){
            for(int x = 0; x < n; x++){
                cin >> A[y][x];
            }
        }
        fill(dp[0].begin(), dp[0].end(), 1);
        for(int i = 0; i + 1 < m; i++){
            for(int j = 0; j < n; j++){
                for(int k = 0; k < n; k++){
                    dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] * A[j][k]);
                }
            }
        }
        printf("%.2lf\n", *max_element(dp[m - 1].begin(), dp[m - 1].end()));
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3560
final_rank: 16