Problem:
シルクロード (Silk Road)
問題
現在カザフスタンがある地域には，古くは「シルクロード」と呼ばれる交易路があった．
シルクロード上には N + 1 個の都市があり，西から順に都市 0, 都市 1, ... , 都市 N と番号がつけられている．都市 i - 1 と都市 i の間の距離 (1 ≤ i ≤ N) は D
i
である．
貿易商である JOI 君は，都市 0 から出発して，都市を順番に経由し，都市 N まで絹を運ぶことになった．都市 0 から都市 N まで M 日以内に移動しなければならない．JOI 君は，それぞれの日の行動として，以下の 2 つのうちいずれか 1 つを選ぶ．
移動： 現在の都市から 1 つ東の都市へ 1 日かけて移動する．現在都市 i - 1 (1 ≤ i ≤ N) にいる場合は，都市 i に移動する．
待機： 移動を行わず，現在いる都市で 1 日待機する．
移動は大変であり，移動するたびに疲労度が溜まっていく．シルクロードでは日毎に天候の変動があり，天候が悪い日ほど移動には苦労を要する．
JOI 君が絹を運ぶのに使える M 日間のうち j 日目 (1 ≤ j ≤ M) の天候の悪さは C
j
であることが分かっている．都市 i - 1 から都市 i (1 ≤ i ≤ N) に j 日目 (1 ≤ j ≤ M) に移動する場合，疲労度が D
i
× C
j
だけ溜まってしまう．移動を行わず待機している日は疲労度は溜まらない．
JOI 君は，それぞれの日の行動をうまく選ぶことで，できるだけ疲労度を溜めずに移動したい．JOI 君が M 日以内に都市 N に移動するときの，移動を開始してから終了するまでに溜まる疲労度の合計の最小値を求めよ．
入力
入力は 1 + N + M 行からなる．
1 行目には，2 つの整数 N, M (1 ≤ N ≤ M ≤ 1000) が空白を区切りとして書かれている．これは，シルクロードが N + 1 個の都市からなり，JOI 君が絹を都市 0 から都市 N まで M 日以内に運ばなければならないことを表す．
続く N 行のうちの i 行目 (1 ≤ i ≤ N) には，整数 D
i
(1 ≤ D
i
≤ 1000) が書かれている．これは，都市 i - 1 と都市 i の間の距離が D
i
であることを表す．
続く M 行のうちの j 行目 (1 ≤ j ≤ M) には，整数 C
j
(1 ≤ C
j
≤ 1000) が書かれている．これは，j 日目の天候の悪さが C
j
であることを表す．
出力
JOI 君が M 日以内に都市 N に移動するときの，移動を開始してから終了するまでに溜まる疲労度の合計の最小値を 1 行で出力せよ．
入出力例
入力例 1
3 5
10
25
15
50
30
15
40
30
出力例 1
1125
入力例 2
2 6
99
20
490
612
515
131
931
1000
出力例 2
31589
入出力例 1 において，溜まる疲労度の合計を最小にするように JOI 君が移動するには次のようにする．
1 日目は待機する．
2 日目に都市 0 から都市 1 へ移動する．このとき溜まる疲労度は 10 × 30 = 300 である．
3 日目に都市 1 から都市 2 へ移動する．このとき溜まる疲労度は 25 × 15 = 375 である．
4 日目は待機する．
5 日目に都市 2 から都市 3 へ移動する．このとき溜まる疲労度は 15 × 30 = 450 である．
JOI 君がこのように移動した場合に溜まる疲労度の合計は 300 + 375 + 450 = 1125 である．これが最小値である．
問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

vector<long long> dijkstra(int v,int r,const vector<vector<pair<int,int>>>& graph){
    const long long INF=LLONG_MAX;
    vector<long long> dist(v,INF);
    dist[r]=0;

    priority_queue<pair<long long,int>,vector<pair<long long,int>>,greater<>> pq;
    pq.push({0,r});

    while(!pq.empty()){
        auto [current_dist,u]=pq.top();
        pq.pop();
        if(current_dist>dist[u]) continue;
        
        for(auto& [to,weight]:graph[u]){
            long long new_dist=current_dist+weight;
            if(new_dist<dist[to]){
                dist[to]=new_dist;
                pq.push({new_dist,to});
            }
        }
    }
    return dist;
}

int main(){
    int n,m;
    cin >> n >> m;
    vector<int> d(n+1),c(m+1);
    for(int i=1;i<=n;i++){
        cin >> d[i];
    }
    for(int i=1;i<=m;i++){
        cin >> c[i];
    }
    int v=(n+1)*(m+1);
    vector<vector<pair<int,int>>> graph(v);
    auto id=[&](int i,int j)->int{
        return i*(m+1)+j;
    };
    for(int i=0;i<=n;i++){
        for(int j=0;j<=m;j++){
            int u=id(i,j);
            if(j<m){
                graph[u].push_back({id(i,j+1),0});
            }
            if(i<n && j<m){
                int cost=d[i+1]*c[j+1];
                graph[u].push_back({id(i+1,j+1),cost});
            }
        }
    }
    vector<long long> dist=dijkstra(v,id(0,0),graph);
    cout << dist[id(n,m)] << endl;
    return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 53728
final_rank: 13

code_snippet: #include <iostream>
#include <vector>
#include <queue>
#include <tuple>
#include <algorithm>

using namespace std;

int main()
{
	int N, M; cin >> N >> M;
	vector<int> D(N), C(M);
	for (auto& d : D) cin >> d;
	for (auto& c : C) cin >> c;
	vector<vector<int>> S(N + 1, vector<int> (M + 1, 1 << 30));
	using T = tuple<int, int, int>;
	priority_queue<T, vector<T>, greater<T>> Q;
	for (Q.push({0, 0, 0}); !Q.empty();) {
		auto [cd, t, n] = Q.top(); Q.pop();
		if (S[n][t] <= cd) continue;
		S[n][t] = cd;
		if (n >= N) continue;
		for (; N - n <= M - t; ++t) Q.push({cd + C[t] * D[n], t + 1, n + 1});
	}
	cout << *min_element(S.back().begin(), S.back().end()) << endl;
	return 0;
}
accuracy: 1
time_ms: 7630
memory_kb: 53484
final_rank: 14

code_snippet: #include<bits/stdc++.h>
 
#define lol long long
#define gcd(x,y) __gcd(x,y)
#define mt make_tuple
#define mp make_pair
#define fi first
#define se second
#define fixed(x) fixed<<setprecision(x)
using namespace std;
using pii=pair<int,int>;
template <class A, class B> inline bool chmax(A &a, const B &b) { return b > a && (a = b, true); }
template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }
template <class A> inline lol abs(A &a) { return (a < 0 ? -a : a); }
bool inLine(int x,int y,int mx,int my){return (x>=0&&y>=0&&x<mx&&y<my);}
const lol inf=(1LL<<62);
const int MOD=(1e9)+7;
const int mod=998244353;
const int dx[]={1,0,-1,0,1,1,-1,-1};
const int dy[]={0,1,0,-1,1,-1,1,-1};
int n,m;
lol d[2000],c[2000];
lol mem[2000][2000];
lol dp(int p,int q){
  if(p>=n) return 0;
  if(mem[p][q]!=-1) return mem[p][q];
  lol ans=inf;
  for(int i=q;i<m;i++){
    chmin(ans,dp(p+1,i+1)+d[p]*c[i]);
  }
  return mem[p][q]=ans;
}
signed main(){
  cin.tie(0);
  ios::sync_with_stdio(false);
  memset(mem,-1,sizeof(mem));
  cin >>n>>m;
  for(int i=0;i<n;i++) cin >>d[i];
  for(int i=0;i<m;i++) cin >>c[i];
  cout <<dp(0,0)<<'\n';
  return (0);
}
accuracy: 1
time_ms: 320
memory_kb: 34456
final_rank: 12

code_snippet: #include <bits/stdc++.h>
#include <math.h>

using namespace std;

long long inf=1000000007;

int main(){
	int n,m;
	cin>>n>>m;
	vector<long long> dis(n);
	vector<long long> wea(m);

	for(int i=0;i<n;i++) cin>>dis.at(i);
	for(int i=0;i<m;i++) cin>>wea.at(i);

	vector<vector<long long>> dp(n+1,vector<long long>(m+1,inf));
	dp.at(0).at(0)=0;

	long long ans=inf;

	queue<pair<long long,long long>> que;
	que.push(make_pair(0,0));

	while(!que.empty()){
		long long here=que.front().first;
		long long date=que.front().second;
		que.pop();

		if(here==n){
			ans=min(ans,dp.at(here).at(date));
			continue;
		}

		if(date<m){
			if(here<n){
				if(dp.at(here+1).at(date+1)>dp.at(here).at(date)+dis.at(here)*wea.at(date)){
					que.push(make_pair(here+1,date+1));
					dp.at(here+1).at(date+1)=dp.at(here).at(date)+dis.at(here)*wea.at(date);
				}
			}

			if(dp.at(here).at(date+1)>dp.at(here).at(date)){
				que.push(make_pair(here,date+1));
				dp.at(here).at(date+1)=dp.at(here).at(date);
			}
		}
	}

	cout<<ans<<endl;

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 9204
final_rank: 4

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
long long test[1001], uiop[1001], dp[1001][1001];
int main() {
	long long n, a, b, c, ans = 100000000000; cin >> n >> a;
	for (int h = 1; h <= n; h++) {
		cin >> b; test[h] = b;
	}
	for (int h = 1; h <= a; h++) {
		cin >> c; uiop[h] = c;
	}
	for (int h = 1; h < 1001; h++) {
		for (int i = 0; i < 1001; i++) {
			dp[h][i] = 100000000001;
		}
	}
	for (int h = 1; h <= n; h++) {
		for (int i = 1; i <= a; i++) {
			if (h <= i) {
				if (h == 1) {
					for (int j = 1; j <= i; j++) {
						dp[h][i] = min(dp[h][i], dp[h - 1][j]);
					}
				}
				else {
					for (int j = 1; j < i; j++) {
						dp[h][i] = min(dp[h][i], dp[h - 1][j]);
					}
				}
				dp[h][i] += test[h] * uiop[i];
			}
		}
	}
	for (int h = 1; h <= a; h++) {
		ans = min(ans, dp[n][h]);
	}
	cout << ans << endl;
	cin >> n;
}
accuracy: 1
time_ms: 230
memory_kb: 10948
final_rank: 9

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
long long test[1001], uiop[1001], dp[1001][1001];
int main() {
	long long n, a, b, c, ans = 10000000; cin >> n >> a;
	for (int h = 1; h <= n; h++) {
		cin >> b; test[h] = b;
	}
	for (int h = 1; h <= a; h++) {
		cin >> c; uiop[h] = c;
	}
	for (int h = 1; h < 1001; h++) {
		for (int i = 0; i < 1001; i++) {
			dp[h][i] = 10000001;
		}
	}
	for (int h = 1; h <= n; h++) {
		for (int i = 1; i <= a; i++) {
			if (h <= i) {
				if (h == 1) {
					for (int j = 1; j <= i; j++) {
						dp[h][i] = min(dp[h][i], dp[h - 1][j]);
					}
				}
				else {
					for (int j = 1; j < i; j++) {
						dp[h][i] = min(dp[h][i], dp[h - 1][j]);
					}
				}
				dp[h][i] += test[h] * uiop[i];
			}
		}
	}
	for (int h = 1; h <= a; h++) {
		ans = min(ans, dp[n][h]);
	}
	cout << ans << endl;
	cin >> n;
}
accuracy: 0.5714285714285714
time_ms: 170
memory_kb: 10924
final_rank: 17

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

using i64 = int64_t;

constexpr i64 INF = 1e12;

struct Node{
    i64 n, m, cost;
    bool operator<(const Node &obj)const{
        return cost > obj.cost;
    }
};

i64 mini[1003][1003]={0};

int main(){
    int n, m;
    cin >> n >> m;
    vector<i64> d;
    for(int i=0;i<n;++i){
        i64 tmp;
        cin >> tmp;
        d.push_back(tmp);
    }
    vector<i64> c;
    for(int i=0;i<m;++i){
        i64 tmp;
        cin >> tmp;
        c.push_back(tmp);
    }

    for(int i=0;i<=n;++i){
        for(int j=0;j<=m;++j){
            mini[i][j] = INF;
        }
    }

    mini[0][0] = 0;
    priority_queue<Node> que;
    que.push((Node){0, 0, 0});
    while(!que.empty()){
        Node curr = que.top(); que.pop();
        if(curr.n == n){
            cout << curr.cost << endl;
            break;
        }
        if(curr.m + 1 <= m){
            i64 cost = curr.cost;
            if(mini[curr.n][curr.m+1] > cost){
                mini[curr.n][curr.m+1] = cost;
                que.push((Node){curr.n, curr.m+1, cost});
            }
            cost += d[curr.n] * c[curr.m];
            if(mini[curr.n+1][curr.m+1] > cost){
                mini[curr.n+1][curr.m+1] = cost;
                que.push((Node){curr.n+1, curr.m+1, cost});
            }
        }
    }

    return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 9660
final_rank: 6

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

#define INF 999999999
vector<int>C, D;
int N, M;

vector<vector<int> > memo;

int main() {
	cin >> N >> M;

	for (int i = 0; i < N; i++) {
		int tmp;
		cin >> tmp;
		D.push_back(tmp);
	}
	for (int i = 0; i < M; i++) {
		int tmp;
		cin >> tmp;
		C.push_back(tmp);
	}

	memo = vector<vector<int> >(N, vector <int>(M, INF));

	for (int i = N - 1; i >= 0; i--)for (int j = M - 1; j >= 0; j--) {
		if (i > j)continue;
		if (i == N - 1) {
			memo[i][j] = D[i] * C[j];
		}
		else {
			int a = INF;
			for (int k = i + 1; k < M; k++) {
				if (j < k) {
					if (a > memo[i + 1][k])a = memo[i + 1][k];
				}
			}
			memo[i][j] = a + D[i]*C[j];
		}
	}

	int ans = INF;
	for (int i = 0; i < M; i++) {
		if (ans > memo[0][i])ans = memo[0][i];
	}

	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 200
memory_kb: 9220
final_rank: 8

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

#define INF 999999999
vector<int>C, D;
int N, M;

vector<vector<int> > memo;

int main() {
	cin >> N >> M;

	for (int i = 0; i < N; i++) {
		int tmp;
		cin >> tmp;
		D.push_back(tmp);
	}
	for (int i = 0; i < M; i++) {
		int tmp;
		cin >> tmp;
		C.push_back(tmp);
	}

	memo = vector<vector<int> >(N, vector <int>(M, INF));

	for (int i = N - 1; i >= 0; i--)for (int j = M - 1; j >= 0; j--) {
		if (i > j)continue;
		if (i == N - 1) {
			memo[i][j] = D[i] * C[j];
		}
		else {
			int a = INF;
			for (int k = i + 1; k < M; k++) {
				if (j < k) {
					if (a > memo[i + 1][k])a = memo[i + 1][k];
				}
			}
			memo[i][j] = a + D[i]*C[j];
		}
	}

	int ans = INF;
	for (int i = 0; i < M; i++) {
		if (ans > memo[0][i])ans = memo[0][i];
	}
	
	/*
	for (int i = 0; i < N; i++)for (int j = 0; j < M; j++) {
		cout << memo[i][j] << " ";
		if (j == M - 1) cout << endl;
	}*/
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 210
memory_kb: 9136
final_rank: 7

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

#define INF 99999999
vector<int>C, D;
int N, M;

vector<vector<int> > memo;

int main() {
	cin >> N >> M;

	for (int i = 0; i < N; i++) {
		int tmp;
		cin >> tmp;
		D.push_back(tmp);
	}
	for (int i = 0; i < M; i++) {
		int tmp;
		cin >> tmp;
		C.push_back(tmp);
	}

	memo = vector<vector<int> >(N, vector <int>(M, INF));

	for (int i = N - 1; i >= 0; i--)for (int j = M - 1; j >= 0; j--) {
		if (i > j)continue;
		if (i == N - 1) {
			memo[i][j] = D[i] * C[j];
		}
		else {
			int a = INF;
			for (int k = i + 1; k < M; k++) {
				if (j < k) {
					if (a > memo[i + 1][k])a = memo[i + 1][k];
				}
			}
			memo[i][j] = a + D[i]*C[j];
		}
	}

	int ans = INF;
	for (int i = 0; i < M; i++) {
		if (ans > memo[0][i])ans = memo[0][i];
	}
	
	/*
	for (int i = 0; i < N; i++)for (int j = 0; j < M; j++) {
		cout << memo[i][j] << " ";
		if (j == M - 1) cout << endl;
	}*/
	cout << ans << endl;
	return 0;
}
accuracy: 0.8571428571428571
time_ms: 200
memory_kb: 9216
final_rank: 15

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

#define INF 99999999
vector<int>C, D;
int N, M;

vector<vector<int> > memo;

int main() {
	cin >> N >> M;

	for (int i = 0; i < N; i++) {
		int tmp;
		cin >> tmp;
		D.push_back(tmp);
	}
	for (int i = 0; i < M; i++) {
		int tmp;
		cin >> tmp;
		C.push_back(tmp);
	}

	memo = vector<vector<int> >(N, vector <int>(M, INF));

	for (int i = N - 1; i >= 0; i--)for (int j = M - 1; j >= 0; j--) {
		if (i == N - 1) {
			if (i > j)continue;
			memo[i][j] = D[i] * C[j];
		}
		else {
			int a = INF;
			for (int k = i + 1; k < M; k++) {
				if (j < k) {
					if (a > memo[i + 1][k])a = memo[i + 1][k];
				}
			}
			memo[i][j] = a + D[i]*C[j];
		}
	}

	int ans = INF;
	for (int i = 0; i < M; i++) {
		if (ans > memo[0][i])ans = memo[0][i];
	}
	
	/*
	for (int i = 0; i < N; i++)for (int j = 0; j < M; j++) {
		cout << memo[i][j] << " ";
		if (j == M - 1) cout << endl;
	}*/
	cout << ans << endl;
	return 0;
}
accuracy: 0.8571428571428571
time_ms: 320
memory_kb: 9204
final_rank: 16

code_snippet: #include <iostream>
using namespace std;
int n,m;
int cities[1000],days[1000];
int mini=1000000;
int Min(int x , int y){
        if(x==-1)
                return y;
        else if(y==-1)
                return x;
        return x<y?x:y;
}
int now[1000][1000]={0};
int dp[1000][1000]={0};
int recursion(int city,int day,int stack){
        if(city==n){
                mini=Min(mini,stack);
                return mini;
        }
//      else if(dp[city][day]!=0){
//              now[city][day]++;
//              return dp[city][day];
//      }
        else if(day==m) return -1;
        else{
                int tmp1=recursion(city+1,day+1,stack+(cities[city]*days[day]));
                int tmp2=recursion(city,day+1,stack);
                dp[city][day]=Min(tmp1,tmp2);
                return dp[city][day];
        }
}
int main(){
        cin >> n >> m;
        for(int i=0 ; i<n ; i++ )
                cin >> cities[i];
        for(int i=0 ; i<m ; i++ )
                cin >> days[i];
        int tmp=recursion(0,0,0);
        cout << mini << endl;
        return 0;
}
accuracy: 0.2857142857142857
time_ms: 10
memory_kb: 3108
final_rank: 20

code_snippet: #define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <math.h>
#include <queue>
#include <stack>
#include <list>
#include <functional>

using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)

int N, M;
int D[1234];
int C[1234];
long long int memo[1234][1234];

long long int dp(int i, int j) {
	if (i == 0) return 0;
	if (j == 0) return 1145141919810;
	if (memo[i][j] != -1) return memo[i][j];
	return memo[i][j] = min(dp(i - 1, j - 1) + D[i - 1] * C[j - 1], dp(i, j - 1));
}

int main() {

	memset(memo, 0xff, sizeof(memo));

	scanf("%d %d", &N, &M);

	rep(i, N) scanf("%d", &D[i]);
	rep(i, M) scanf("%d", &C[i]);

	printf("%lld\n", dp(N, M));

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 14640
final_rank: 11

code_snippet: #include<iostream>
using namespace std;
int n,m;
int d[1001];
int c[1001];
int dp[1002][1001];
int dp_hiroudo(int i,int j){
  if(i==n){
    return 0;
  }else if(dp[i][j]==-1){
    dp[i][j]=min(dp_hiroudo(i+1,j+1)+d[i]*c[j],dp_hiroudo(i,j+1));
  }
  return dp[i][j];
}
int main(){
  cin >>n>>m;
  for(int i=0;i<n;i++)cin >>d[i];
  for(int i=0;i<m;i++)cin >>c[i];
  for(int i=0;i<1002;i++){
    for(int j=0;j<1001;j++){
      if(n-i>m-j)dp[i][j]=1000000000;
      else dp[i][j]=-1;
    }
  }
  dp_hiroudo(0,0);
  cout <<dp[0][0]<<endl;
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 7056
final_rank: 2

code_snippet: #include<iostream>
using namespace std;
int n,m;
int d[1001];
int c[1001];
int dp[1001][1000];
int dp_hiroudo(int i,int j){
  if(i==n){
    return 0;
  }else if(dp[i][j]==-1){
    dp[i][j]=min(dp_hiroudo(i+1,j+1)+d[i]*c[j],dp_hiroudo(i,j+1));
  }
  return dp[i][j];
}
int main(){
  cin >>n>>m;
  for(int i=0;i<n;i++)cin >>d[i];
  for(int i=0;i<m;i++)cin >>c[i];
  for(int i=0;i<1001;i++){
    for(int j=0;j<1000;j++){
      if(n-i>m-j)dp[i][j]=1000000000;
      else dp[i][j]=-1;
    }
  }
  dp_hiroudo(0,0);
  cout <<dp[0][0]<<endl;
  return 0;
}
accuracy: 0.5714285714285714
time_ms: 10
memory_kb: 38160
final_rank: 19

code_snippet: #include<iostream>
using namespace std;
int dp[1001][1001];
int main(){
	int n,m,i,i2,i3,d[1000],c[1000],yamagutigumi,takahashi=2100000000;
	cin>>n>>m;
	for(i=0;i<n;i++){
		for(i2=0;i2<m;i2++){
			dp[i][i2]=2100000000;
		}
	}
	for(i=0;i<n;i++){
		cin>>d[i];
	}
	for(i=0;i<m;i++){
		cin>>c[i];
		dp[0][i]=c[i]*d[0];
	}
	for(i=1;i<n;i++){
		for(i2=0;i2<m;i2++){
			for(i3=i2;i3<m;i3++){
				if(i2==i3)i3++;
				if(i3>m)break;
				yamagutigumi=d[i]*c[i3]+dp[i-1][i2];
				if(dp[i][i3]>yamagutigumi){
					dp[i][i3]=yamagutigumi;
				}
			}
		}
	}
	/*for(i=0;i<n;i++){
		for(i2=0;i2<m;i2++){
			cout<<dp[i][i2]<<' ';
		}
		cout<<endl;
	}*/
	for(i=0;i<m;i++){
		takahashi=min(takahashi,dp[n-1][i]);
	}
	cout<<takahashi<<endl;
}
accuracy: 1
time_ms: 540
memory_kb: 6240
final_rank: 5

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
	long long dp[1001][1001];
	long long  e[1001][1001];
	long long  ans[1001];
	long long n,m,d[1001],c[1001];
int main(){
		cin>>n>>m;
	for(int i=0;i<n;i++){
		cin>>d[i];
	}
	for(int i=0;i<m;i++){
		cin>>c[i];
	}
	for(int i=0;i<m-(n-1);i++){
		dp[0][i]=d[0]*c[i];
	}
	//cout<<" ++++++"<<endl;
	for(int i=1;i<n;i++){
		for(int j=i;j<m-(n-i)+1;j++){
			//cout<<"====="<<endl;
			for(int z=i-1;z<j;z++){
				//cout<<"QQQQQQQ"<<endl;
				ans[z-i+1]=dp[i-1][z];
			}
			sort(ans,ans+j-(i-1));
			dp[i][j]=ans[0]+d[i]*c[j];
		}
	}
	for(int i=n-1;i<m;i++){
		ans[i-(n-1)]=dp[n-1][i];
	}
	sort(ans,ans+(m-n)+1);
	cout<<ans[0]<<endl;
}
accuracy: 1
time_ms: 840
memory_kb: 7428
final_rank: 10

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

#define llong long long 
#define inf 9999999999
int N, M;
llong int D[1001];
llong int C[1001];
llong int score[1001][1000][2];

llong int solve(int day, int now, llong int wry, int go){
	// cout << day << " " << now << " " << wry << " " << score[day][now][go] << endl;
	if(score[day][now][go] != inf) return score[day][now][go];
	if(day > M)return inf;
	if(now == N){
		if(score[day][now][go] > wry) return score[day][now][go] = wry;
		else return inf;
	}

	llong int ret = inf;
	ret = min(ret, solve(day + 1, now, 0, 0) + wry);
	llong int walk = D[now + 1] * C[day + 1];
	ret = min(ret, solve(day + 1, now + 1, walk, 1) + wry);

	return score[day][now][go] = ret;
}

int main(){
	fill_n(D, 1000, -1);
	fill_n(C, 1001, -1);
	fill_n(**score, 1001 * 1000 * 2, inf);
	cin >> N >> M;
	for(int i = 1; i <= N; i++){
		cin >> D[i];
	}
	for(int i = 1; i <= M; i++){
		cin >> C[i];
	}

	cout << solve(0, 0, 0, 0) << endl;
	return 0;
}
accuracy: 0.5714285714285714
time_ms: 1400
memory_kb: 18780
final_rank: 18

code_snippet: #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <functional>

using namespace std;

#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define omajinai ios::sync_with_stdio(false);cin.tie(0)
#define rep(i,x) for(int i=0;i<(int)(x);++i)
#define rep1(i,x) for(int i=1;i<=(int)(x);++i)
#define rrep(i,x) for(int i=(int)x-1;i>=0;--i)
#define rrep1(i,x) for(int i=(int)x;i>=1;--i)

using ll=long long;
using ld=long double;
using vi=vector<int>;
using vvi=vector<vi>;
using pii=pair<int, int>;
using vpii=vector<pii>;

template<class T,class U>ostream&operator<<(ostream&os,const pair<T,U>p){os<<"("<<p.fst<<", "<<p.scd<<")";return os;}
template<class T>ostream&operator<<(ostream&os,const vector<T>v){rep(i,v.size()){if(i)os<<", ";os<<v[i];}return os;}
template<typename T>T&max(T&a,T&b){if(a>=b)return a;return b;}
template<typename T>T&min(T&a,T&b){if(a < b)return a;return b;}
template<typename T>bool chmax(T&a,T b){if(a < b){a=b;return true;}return false;}
template<typename T>bool chmin(T&a,T b){if(a > b){a=b;return true;}return false;}

constexpr int inf = 1e9;
constexpr ll linf = 3e18;
constexpr double eps = 1e-9;

int N, M;
int D[1010], C[1010];

int dp[1010][1010];

int rec(int i, int j)
{
    if (j == N) return 0;
    if (i == M) return inf;

    int& res = dp[i][j];

    if (~res) return res;

    res = min(rec(i + 1, j), rec(i + 1, j + 1) + C[i] * D[j]);

    return res;
}

signed main()
{
    cin >> N >> M;

    rep(i, N) cin >> D[i];
    rep(i, M) cin >> C[i];

    memset(dp, -1, sizeof(dp));

    cout << rec(0, 0) << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 7056
final_rank: 2

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
#include<map>

using namespace std;

int dp[1000][1000] = {};
int INF = 999999999;

int main(){
	int N, M;
	int D[1000] = {}, C[1000] = {};
	cin >> N >> M;
	for (int i = 0; i < N; i++){
		cin >> D[i];
	}
	for (int i = 0; i < M; i++){
		cin >> C[i];
	}

	for (int i = 0; i <= N; i++){
		for (int j = i; j <= M; j++){
			if (i == 0 || j == 0) dp[i][j] = 0;
			else{
				int tmp1 = INF;
				for (int k = i-1; k < j; k++){
					int tmp2 = dp[i-1][k];
					if (tmp1>tmp2){
						tmp1 = tmp2;
					}
				}
				if (tmp1 == INF) tmp1 = 0;
				dp[i][j] = tmp1+(C[j-1]*D[i-1]);
			}
		}
	}
	/*
	for (int i = 0; i <= N; i++){
		for (int j = 0; j <= M; j++){
			cout << dp[i][j] << " ";
		}
		cout << endl;
	}
	*/

	int tmp = INF;
	for (int i = 0; i <= M; i++){
		if (tmp > dp[N][i]&& dp[N][i]!=0)tmp = dp[N][i];
	}

	cout << tmp << endl;
	
}
accuracy: 1
time_ms: 120
memory_kb: 6212
final_rank: 1