Problem:
人生ゲーム
太郎君は、おもちゃ屋さんに会津ホビー社製の人生ゲームを買いに行きました。人生ゲームは、マス目の書かれたボードとルーレットを使って遊びます。ボードには図のようにスタート地点とゴール地点が一つずつあり、それらはひとつながりのマス目でつながっています。最初に、コマはスタート地点のマスに置かれ、ルーレットを回して出た数によってコマを進めます。マスによっては、そこに止まったり通過したりすることでお金を得たり、コマの位置を変えたりするイベントマスがあります。最終的な勝敗は、コマがゴール地点に到達した時点の所持金の多寡で決まります。
この会社の人生ゲームの面白いところは、ルーレットの出る目の大きさ、ゴールまでのマスの数、イベントマスの配置がひとつひとつパッケージごとに異なるところです。それらはケースに書かれており、それを読むことで確認することができます。お金を最も得られる人生ゲームを選びたい太郎君は、得るお金の期待値が一番大きいものを買いたがっています。そこであなたは、太郎君のゲーム選びを手伝うことにしました。
ルーレットは、円周を
X
等分に区分され、それぞれに
V
1
、
V
2
、...、
V
X
という値が記入されているとします。ボードには、0 番、1 番、...、
Y
番と番号がふられたマス目があり、順番につながっています。マス目の中には、イベントマスと呼ばれる特別なマスが
Z
個あり、そこに到達すると特別な動作を行います。イベントマスのマス目の番号は
N
i
で与えられます。イベントマスには 1 ~ 3 の種類 (
E
i
)  があり、それぞれ次の動作が行われます。
種類 (
E
i
)
特別動作
値 (
A
i
) の範囲
1
指定の値
A
i
だけ先へ進む
1~10
2
指定の値
A
i
の金額を得る
1~100
3
指定の値
A
i
の金額を支払う
1~100
最初の所持金は 0 円で、第 0 マス目からスタートし、第
Y
マス目に到達するとゴールとなります。ゴールを越えた場合もゴールと見なします。スタートとゴールにイベントは無く、1 マスに複数のイベントが重なることはありません。イベントによって進んだ先のマスのイベントは無視します。所持金が 0 円より少なくなる場合は 0 円とします。
例えば、ある人生ゲームで得られるお金の期待値は以下のように計算できます。
この例では、スタート、イベントマス(100 円入手) 、ゴールの 3 つのマスと、1 か 2 が出るルーレットからなる人生ゲームが表されています。まず、1 回目にルーレットを回した時、1 が出ればイベントマスに到達し、所持金は 100 円になります。一方、2 が出た場合はゴールに到達し、所持金は 0 円のままです。これらはどちらも 2 分の 1 の確率で起こります。
さらに、1 回目でイベントマスに到達した場合は 2 回目のルーレットを回しますが、どの値が出てもゴールに到達し、所持金はどの場合も 100 円です。
このように、全部で 3 通りのゴールの仕方があります。ゴールした時点の所持金に着目すると、0 円になる場合が 1 通りでその確率は 2 分の 1、100 円になる場合が 2 通りでその確率が 4 分の 1 です。この場合、ゴールでの所持金の期待値は、ゴールの仕方ごとの    (所持金 × その確率)   を足した値であり、この人生ゲームの期待値は 50 円になります。
ルーレットの情報とボードの情報を入力とし、ゴール時の所持金の期待値を出力するプログラムを作成してください。
Input
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロみっつの行で示されます。各データセットは以下の形式で与えられます。
X
Y
Z
V
1
V
2
...
V
X
N
1
E
1
A
1
N
2
E
2
A
2
:
N
Z
E
Z
A
Z
X
(1 ≤
X
≤ 4)、
V
i
(1 ≤
V
i
≤ 10)、
Y
(1 ≤
Y
≤ 50)、
N
i
(1 ≤
N
i
≤
Y
-1)、
Z
(0 ≤
Z
≤
Y
-1)、
E
i
(1 ≤
E
i
≤ 3)、
A
i
(1 ≤
A
i
≤ 100) は整数で与えられます。
データセットの数は 100 を超えません。
Output
入力データセットごとに、最終的な所持金の期待値を１行に出力します。なお、所持金の期待値は小数点以下切り捨ての整数で出力してください。
Sample Input
1 2 0
1
1 2 1
1
1 2 100
1 2 1
2
1 2 100
2 2 1
1 2
1 2 100
4 5 3
1 2 3 4
1 1 2
2 2 100
4 3 60
0 0 0
Output for the Sample Input
0
100
0
50
20

Submitted solutions:

code_snippet: #include <iostream>

#include <cstring>

using namespace std;



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



int X, Y, Z;

int V[4];

struct Cell

{

    int N, E, A;

};

Cell cells[51];



float dp[51][50 * 100];



int main() {

    while(true) {

        cin >> X >> Y >> Z;

        if(!X && !Y && !Z) break;



        rep(i, X) cin >> V[i];



        memset(cells, 0, sizeof(int) * 3 * (Y + 1));

        rep(i, Z) {

            Cell cell;

            cin >> cell.N >> cell.E >> cell.A;

            cells[cell.N] = cell;

        }



        rep(i, Y + 1) {

            rep(j, 100 * Y) {

                dp[i][j] = 0.0;

            }

        }

        dp[0][0] = 1.0;



        rep(i, Y) {

            rep(j, 100 * Y) {

                if(dp[i][j] == 0.0) continue;



                rep(k, X) {

                    int money = j, current = i + V[k];

                    if(current > Y) current = Y;

                    Cell &cell = cells[current];

                    switch(cell.E) {

                        case 1:

                            current += cell.A;

                            break;

                        case 2:

                            money += cell.A;

                            break;

                        case 3:

                            money -= cell.A;

                            if(money < 0) money = 0;

                            break;

                    }

                    if(current > Y) current = Y;

                    dp[current][money] += dp[i][j] / X;

                }

            }

        }

        /*

        rep(i, Y + 1) {

            rep(j, 101) {

                cout.width(4);

                cout << dp[i][j];

            }

            cout << endl;

        }

        */



        float ans = 0.0;

        rep(i, 100 * Y) {

            ans += dp[Y][i] * i;

        }

        cout << (int)ans << endl;

    }



    return 0;

}
accuracy: 1
time_ms: 10
memory_kb: 4056
final_rank: 1

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

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int X, Y, Z;
    while(cin >> X >> Y >> Z, Y){
        vector<int> V(X);
        vector<array<int,3>> mas(Y + 1, {0, 0, 0});
        for(auto &&v:V)cin >> v;
        int N, E, A;
        while(Z--){
            cin >> N >> E >> A;
            mas[N][--E] += A;
        }
        vector<vector<double>> dp(Y + 1, vector<double>(5001, -1));
        function<double(int,int)> rec = [&](int v, int c){
            if(v >= Y)return double(c);
            if(dp[v][c] != -1)return dp[v][c];
            double res = 0;
            for(auto adv:V){
                res += rec(v + adv + mas[v][0], max(0, c + mas[v][1] - mas[v][2]));
            }
            return dp[v][c] = res / X;
        };
        cout << int(rec(0, 0)) << '\n';
    }
}
accuracy: 1
time_ms: 30
memory_kb: 5108
final_rank: 10

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

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int X, Y, Z;
    while(cin >> X >> Y >> Z, Y){
        vector<int> V(X);
        vector<array<int,3>> mas(Y + 1, {0, 0, 0});
        for(auto &&v:V)cin >> v;
        int N, E, A;
        while(Z--){
            cin >> N >> E >> A;
            mas[N][--E] += A;
        }
        vector<vector<double>> dp(Y + 1, vector<double>(5001, -1));
        function<double(int,int)> rec = [&](int v, int c){
            if(v >= Y)return double(c);
            if(dp[v][c] != -1)return dp[v][c];
            //if(mas[v][0])return dp[v][c] = rec(v + mas[v][0], c);
            double res = 0;
            for(auto adv:V){
                res += rec(v + adv + mas[v][0], max(0, c + mas[v][1] - mas[v][2]));
            }
            res /= X;
            return dp[v][c] = res;
        };
        cout << int(floor(rec(0, 0))) << '\n';
    }
}
accuracy: 1
time_ms: 30
memory_kb: 5152
final_rank: 11

code_snippet: #define READ_FROM_FILE 0

#if READ_FROM_FILE
#include <fstream>
#endif

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

const int move_forward = 1;
const int get_money = 2;
const int lose_money = 3;


int solve(const vector<pair<int, int>>& c_vec, const vector<int>& v_vec, const int x, const int y) {
	vector<unordered_map<int, double>> dp(y + 1);
	double expected_money = 0.0;

	dp[0][0] = 1.0;

	for (int i = 0; i < y; i++) {
		for (const auto &m : dp[i]) {
			int c_money = m.first;
			double prob = m.second;
			
			for (const int& v : v_vec) {
				int j = i + v;
				int e = -1;
				int a = -1;
				int n_money = c_money;

				j = min(j, y);
				e = c_vec[j].first;
				a = c_vec[j].second;

				if (e == move_forward) {
					j += a;
					j = min(j, y);
				}
				else if (e == get_money) {
					n_money += a;
				}
				else if (e == lose_money) {
					n_money = max(0, n_money - a);
				}

				if (dp[j].count(n_money) == 0) {
					dp[j][n_money] = prob / x;
				}
				else {
					dp[j][n_money] += prob / x;
				}
			}
		}
	}

	for (auto it = dp[y].begin(); it != dp[y].end(); it++) {
		expected_money += it->first * it->second;
	}

	return int(expected_money);
}


int main(int argc, char** argv) {
#if READ_FROM_FILE
	ifstream ifs("test0.txt");
	cin.rdbuf(ifs.rdbuf());
#endif
	while (true) {
		int x = -1;
		int y = -1;
		int z = -1;
		int v = -1;
		int n = -1;
		int e = -1;
		int a = -1;
		vector<pair<int, int>> c_vec;
		vector<int> v_vec;

		if (true) {
		//if (false) {
			cin >> x >> y >> z;
			if (x == 0 && y == 0 && z == 0) {
				break;
			}

			for (int i = 0; i < x; i++) {
				cin >> v;
				v_vec.push_back(v);
			}

			c_vec.resize(y + 1, pair<int, int>(0, 0));
			for (int i = 0; i < z; i++) {
				cin >> n >> e >> a;
				c_vec[n].first = e;
				c_vec[n].second = a;
			}
		}

		cout << solve(c_vec, v_vec, x, y) << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3996
final_rank: 3

code_snippet: #define READ_FROM_FILE 0

#if READ_FROM_FILE
#include <fstream>
#endif

#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>


using namespace std;
typedef long long ll;

const int move_forward = 1;
const int get_money = 2;
const int lose_money = 3;


ll solve(const vector<pair<int, int>>& c_vec, const vector<int>& v_vec, const int x, const int y) {
	vector<unordered_map<int, double>> dp(y + 1);
	double expected_money = 0.0;

	dp[0][0] = 1.0;

	for (int i = 0; i < y; i++) {
		for (const auto &m : dp[i]) {
			int c_money = m.first;
			double prob = m.second;
			
			for (const int& v : v_vec) {
				int j = i + v;
				int e = -1;
				int a = -1;
				int n_money = c_money;

				j = min(j, y);
				e = c_vec[j].first;
				a = c_vec[j].second;

				if (e == move_forward) {
					j += a;
					j = min(j, y);
				}
				else if (e == get_money) {
					n_money += a;
				}
				else if (e == lose_money) {
					n_money = max(0, n_money - a);
				}

				if (dp[j].count(n_money) == 0) {
					dp[j][n_money] = prob / x;
				}
				else {
					dp[j][n_money] += prob / x;
				}
			}
		}
	}

	for (auto it = dp[y].begin(); it != dp[y].end(); it++) {
		expected_money += it->first * it->second;
	}

	return int(expected_money);
}


int main(int argc, char** argv) {
#if READ_FROM_FILE
	ifstream ifs("test0.txt");
	cin.rdbuf(ifs.rdbuf());
#endif
	while (true) {
		int x = -1;
		int y = -1;
		int z = -1;
		int v = -1;
		int n = -1;
		int e = -1;
		int a = -1;
		vector<pair<int, int>> c_vec;
		vector<int> v_vec;

		if (true) {
		//if (false) {
			cin >> x >> y >> z;
			if (x == 0 && y == 0 && z == 0) {
				break;
			}

			for (int i = 0; i < x; i++) {
				cin >> v;
				v_vec.push_back(v);
			}

			c_vec.resize(y + 1, pair<int, int>(0, 0));
			for (int i = 0; i < z; i++) {
				cin >> n >> e >> a;
				c_vec[n].first = e;
				c_vec[n].second = a;
			}
		}
		//else {
		//	random_device rd;
		//	//make_random_data(rd(), x, y, z, c_vec, v_vec);
		//	make_random_data(20220315, x, y, z, c_vec, v_vec);
		//}

		cout << solve(c_vec, v_vec, x, y) << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3880
final_rank: 2

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

int main() {
    while(1){
        int x,y,z;
        cin >> x >> y >> z;
        if(x == 0) break;

        vector<int> v(x);
        for(int i=0; i<x; i++){
            cin >> v[i];
        }
        vector<int> e(y+1, 0), a(y+1, 0);
        for(int i=0; i<z; i++){
            int idx;
            cin >> idx;
            cin >> e[idx] >> a[idx];
        }

        vector<vector<double>> dp(y+1, vector<double>(z*100+1, 0));
        dp[0][0] = 1;
        for(int i=0; i<y; i++){
            for(int j: v){
                int pos = min(i+j, y);
                int add = 0;
                if(e[pos] == 1){
                    pos = min(pos+a[pos], y);
                }else if(e[pos] == 2){
                    add += a[pos];
                }else if(e[pos] == 3){
                    add -= a[pos];
                }
                for(int k=0; k<z*100+1; k++){
                    int money = max(k+add, 0);
                    if(money > z*100) continue;
                    dp[pos][money] += dp[i][k]/x;
                }
            }
        }
        double ans = 0;
        for(int k=0; k<=z*100; k++){
            ans += dp[y][k]*k;
        }
        cout << (int)(ans+1e-5) << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 5024
final_rank: 12

code_snippet: #include "bits/stdc++.h"
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)             // [0, b)
#define rep2(i, a, b) for (int i = (int)(a); i < (int)(b); i++)  // [a, b)
#define rep3(i, a, b) for (int i = (int)(a); i >= (int)(b); i--) // reversed [a, b] so [b, b-1, ... a]
#define FOR(i, a) for (auto &i: a)
#define ALL(obj) begin(obj), end(obj)
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define SUM(x) accumulate(ALL(x), 0LL)
#define LOWER_BOUND(A, key) distance(A.begin(), lower_bound(ALL(A), key))
#define UPPER_BOUND(A, key) distance(A.begin(), upper_bound(ALL(A), key))

using namespace std;
const int MOD    = (int)(1e9 + 7);
const int INF    = (int)(1e13 + 7);
const double EPS = 1e-14;
const double PI  = acos(-1);

int CEIL(int a, int b) { return (a >= 0 ? (a + (b - 1)) / b : (a - (b - 1)) / b); } //ceil() for int
int mod(int a, int b) { return a >= 0 ? a % b : a - (b * CEIL(a, b)); }             //always return positive num
int pow_mod(int a, int b) {                                                         //return x^y in order(log(y))
  int res = 1;
  for (a %= MOD; b; a = a * a % MOD, b >>= 1)
    if (b & 1) res = res * a % MOD;
  return res;
}

signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  while (1) {
    int X, Y, Z;
    cin >> X >> Y >> Z;
    if (X == 0) break;
    vector<int> V(X);
    rep(i, X) cin >> V[i];
    vector<vector<double>> dp(Y + 10, vector<double>(5000 + 100, 0));
    vector<vector<double>> NEA(Y + 10, vector<double>{});
    rep(i, Z) {
      int N;
      double E, A;
      cin >> N >> E >> A;
      NEA[N] = {E, A};
    }
    dp[0][0] = 1;
    rep(i, Y) {
      rep(j, 5000 + 10) {
        FOR(k, V) {
          if (dp[i][j] != 0) {
            int to = min(i + k, Y);
            if (NEA[to].size()) {
              int E = NEA[to][0];
              int A = NEA[to][1];
              if (E == 1) {
                dp[min(Y, to + A)][j] += dp[i][j] / (double)X;
              } else if (E == 2) {
                dp[to][j + A] += dp[i][j] / (double)X;
              } else {
                dp[to][max(j - A, 0LL)] += dp[i][j] / (double)X;
              }
            } else {
              dp[to][j] += dp[i][j] / (double)X;
            }
          }
        }
      }
    }
    double ans = 0;
    rep(i, 5000 + 10) {
      ans += dp[Y][i] * (double)i;
    }
    cout << (int)(floor(ans)) << endl;
  }
}
accuracy: 1
time_ms: 70
memory_kb: 5556
final_rank: 14

code_snippet: #include "bits/stdc++.h"
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)             // [0, b)
#define rep2(i, a, b) for (int i = (int)(a); i < (int)(b); i++)  // [a, b)
#define rep3(i, a, b) for (int i = (int)(a); i >= (int)(b); i--) // reversed [a, b] so [b, b-1, ... a]
#define FOR(i, a) for (auto &i: a)
#define ALL(obj) begin(obj), end(obj)
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define SUM(x) accumulate(ALL(x), 0LL)
#define LOWER_BOUND(A, key) distance(A.begin(), lower_bound(ALL(A), key))
#define UPPER_BOUND(A, key) distance(A.begin(), upper_bound(ALL(A), key))

using namespace std;
const int MOD    = (int)(1e9 + 7);
const int INF    = (int)(1e13 + 7);
const double EPS = 1e-14;
const double PI  = acos(-1);

int CEIL(int a, int b) { return (a >= 0 ? (a + (b - 1)) / b : (a - (b - 1)) / b); } //ceil() for int
int mod(int a, int b) { return a >= 0 ? a % b : a - (b * CEIL(a, b)); }             //always return positive num
int pow_mod(int a, int b) {                                                         //return x^y in order(log(y))
  int res = 1;
  for (a %= MOD; b; a = a * a % MOD, b >>= 1)
    if (b & 1) res = res * a % MOD;
  return res;
}

signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  while (1) {
    int X, Y, Z;
    cin >> X >> Y >> Z;
    if (X == 0) break;
    vector<int> V(X);
    rep(i, X) cin >> V[i];
    vector<vector<double>> dp(Y + 10, vector<double>(5000 + 100, 0));
    vector<vector<double>> dp2(Y + 10, vector<double>(5000 + 100, 0));
    vector<vector<double>> NEA(Y + 10, vector<double>{});
    rep(i, Z) {
      int N;
      double E, A;
      cin >> N >> E >> A;
      NEA[N] = {E, A};
    }
    dp[0][0] = 1;
    rep(i, Y) {
      rep(j, 5000 + 10) {
        FOR(k, V) {
          if (dp[i][j] != 0) {
            int to = min(i + k, Y);
            if (NEA[to].size()) {
              int E = NEA[to][0];
              int A = NEA[to][1];
              if (E == 1) {
                dp[min(Y, to + A)][j] += dp[i][j] / (double)X;
              } else if (E == 2) {
                dp[to][j + A] += dp[i][j] / (double)X;
              } else {
                dp[to][max(j - A, 0LL)] += dp[i][j] / (double)X;
              }
            } else {
              dp[to][j] += dp[i][j] / (double)X;
            }
          }
        }
      }
    }
    rep(j, 5000 + 10) {
      dp[Y][j] += dp2[Y][j];
    }
    double ans = 0;
    rep(i, 5000 + 10) {
      ans += dp[Y][i] * (double)i;
    }
    cout << (int)(floor(ans)) << endl;
  }
}
accuracy: 1
time_ms: 80
memory_kb: 7884
final_rank: 20

code_snippet: #include <bits/stdc++.h>
//#include <atcoder/all>
#define LOCAL
using namespace std;
//using namespace atcoder;
template <typename A, typename B>
ostream& operator <<(ostream& out, const pair<A, B>& a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
ostream& operator <<(ostream& out, const array<T, N>& a) {
out << "["; bool first = true;
for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
return out;
}
template <typename T>
ostream& operator <<(ostream& out, const vector<T>& a) {
out << "["; bool first = true;
for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
return out;
}
template <typename T, class Cmp>
ostream& operator <<(ostream& out, const set<T, Cmp>& a) {
out << "{"; bool first = true;
for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream& operator <<(ostream& out, const map<U, T, Cmp>& a) {
out << "{"; bool first = true;
for (auto& p : a) { out << (first ? "" : ", "); out << p.first << ":" << p.second; first = 0;} out << "}";
return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
#define rep(i,n) for(int i=0; i<(n); i++)
using ll = long long;
//#define int long long
using P = pair<int,int>;
using P3 = pair<int,P>;
//#########################################
int x,y,z;
void solve(){
    vector<vector<double>> dp(55,vector<double>(55*100));
    vector<int> v(x);
    rep(i,x)cin >> v[i];
    vector<P> res(55,P(-1,-1));
    rep(i,z){
        int n,e,a;cin >> n >> e >> a;
        // n--;
        res[n] = P(e,a);
    }
    dp[0][0] = 1;
    double mul = 1.0;
    rep(i,y)rep(j,55*100){
        // dp[i] = max(dp[i],0.0);
        mul /= (double)x;
        rep(masu,x){
            int next  = i + v[masu];
            double val = 0;
            if(res[next].first == 1){
                next = next + res[next].second;
                dp[min(y,next)][j] += dp[i][j]/(double)x;
                continue;
            }
            else if(res[next].first == 2){
                val = (double)res[next].second;
            }
            else if(res[next].first == 3){
                val = -(double)res[next].second;
            }
           if(j+(int)val < 55*100)dp[min(y,next)][max(0,j+(int)val)] += dp[i][j]/(double)x;
        }
    }
    double tmp = 0;
    rep(i,55*100)tmp += dp[y][i]*(double)i;
    int ret = tmp/1;
    cout << ret << "\n";
}
int main(){
    while(1){
        cin >> x >> y >> z;
        if(x == 0 && y == 0 && z == 0)return 0;
        solve();
    }
    return 0;
}
accuracy: 1
time_ms: 130
memory_kb: 5456
final_rank: 18

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

double dp[100][5000];
int n, m, K, p[100], q[100], d[100], a, b, c;

int main() {
	while (1) {
		rep(i,100){
			p[i] = 0; q[i] = 0;
			rep(j,5000) dp[i][j] = 0;
		}
		cin>>n>>m>>K; if(n == 0) break;

		rep(i,n) cin>>d[i];
		rep(i,K){
			cin>>a>>b>>c; p[a] = b; q[a] = c;
		}

		dp[0][0] = 1;
		rep(i,m){
			rep(j,5000){
				if (dp[i][j] == 0.0)continue;

				rep(k,n){
					int to = min(i + d[k], m);
					if (p[to] == 0)dp[to][j] += dp[i][j] / n;
					if (p[to] == 1)dp[min(to + q[to], m)][j] += dp[i][j] / n;
					if (p[to] == 2)dp[to][j + q[to]] += dp[i][j] / n;
					if (p[to] == 3)dp[to][max(j - q[to], 0)] += dp[i][j] / n;
				}
			}
		}

		double ans = 0;
		for (int i = 0; i < 5000; i++) ans += i*dp[m][i];
		cout << int(ans) << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 6996
final_rank: 13

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

using namespace std;

int X, Y, Z;
int V[4],EventInfo[51][2];
double DpMoney[4901][51];


void solve() {
	int currentNode, currentMoney;

	DpMoney[0][0] = 1.0;
	for (int i = 0; i < Y; ++i) {
		for (int j = 0; j < 4901; ++j) {
			if (DpMoney[j][i] == 0) {
				continue;
			}
			for (int k = 0; k < X; ++k) {	
				currentNode = min(Y, i + V[k]);
				currentMoney = j;
				switch (EventInfo[currentNode][0]) {
					case 1:currentNode = min(Y, currentNode + EventInfo[currentNode][1]); break;
					case 2:currentMoney += EventInfo[currentNode][1]; break;
					case 3:currentMoney = max(0, currentMoney - EventInfo[currentNode][1]); break;
					default:break;
				}
				DpMoney[currentMoney][currentNode] += DpMoney[j][i] / X;
			}
		}
	}

}

int main() {
	int n, e, a;
	double total;

	while (cin >> X >> Y >> Z, X) {
		for (int i = 0; i < X; ++i) {
			cin >> V[i];
		}
		memset(EventInfo, 0, sizeof(EventInfo));
		for (int i = 0; i < Z; ++i) {
			cin >> n >> e >> a;
			EventInfo[n][0] = e;
			EventInfo[n][1] = a;
		}
		memset(DpMoney, 0, sizeof(DpMoney));
		solve();
		total = 0;
		for (int i = 0; i < 4901; ++i) {
			total += i*DpMoney[i][Y];
		}
		cout << (int)total << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4936
final_rank: 5

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

using namespace std;

int X, Y, Z;
int V[4],EventInfo[51][2];
double DpMoney[5000][51];


void solve() {
	int currentNode, currentMoney;

	DpMoney[0][0] = 1.0;
	for (int i = 0; i < Y; ++i) {
		for (int j = 0; j < 5000; ++j) {
			if (DpMoney[j][i] == 0) {
				continue;
			}
			for (int k = 0; k < X; ++k) {	
				currentNode = min(Y, i + V[k]);
				currentMoney = j;
				switch (EventInfo[currentNode][0]) {
					case 1:currentNode = min(Y, currentNode + EventInfo[currentNode][1]); break;
					case 2:currentMoney += EventInfo[currentNode][1]; break;
					case 3:currentMoney = max(0, currentMoney - EventInfo[currentNode][1]); break;
					default:break;
				}
				DpMoney[currentMoney][currentNode] += DpMoney[j][i] / X;
			}
		}
	}

}

int main() {
	int n, e, a;
	double total;

	while (cin >> X >> Y >> Z, X) {
		for (int i = 0; i < X; ++i) {
			cin >> V[i];
		}
		memset(EventInfo, 0, sizeof(EventInfo));
		for (int i = 0; i < Z; ++i) {
			cin >> n >> e >> a;
			EventInfo[n][0] = e;
			EventInfo[n][1] = a;
		}
		memset(DpMoney, 0, sizeof(DpMoney));
		solve();
		total = 0;
		for (int i = 0; i < 5000; ++i) {
			total += i*DpMoney[i][Y];
		}
		cout << (int)total << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4992
final_rank: 7

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

using namespace std;

int X, Y, Z;
int V[4],EventInfo[51][2];
double DpMoney[5001][51];


void solve() {
	int currentNode, currentMoney;

	DpMoney[0][0] = 1.0;
	for (int i = 0; i < Y; ++i) {
		for (int j = 0; j < 5001; ++j) {
			if (DpMoney[j][i] == 0) {
				continue;
			}
			for (int k = 0; k < X; ++k) {	
				currentNode = min(Y, i + V[k]);
				currentMoney = j;
				switch (EventInfo[currentNode][0]) {
					case 1:currentNode = min(Y, currentNode + EventInfo[currentNode][1]); break;
					case 2:currentMoney += EventInfo[currentNode][1]; break;
					case 3:currentMoney = max(0, currentMoney - EventInfo[currentNode][1]); break;
					default:break;
				}
				DpMoney[currentMoney][currentNode] += DpMoney[j][i] / X;
			}
		}
	}

}

int main() {
	int n, e, a;
	double total;

	while (cin >> X >> Y >> Z, X) {
		for (int i = 0; i < X; ++i) {
			cin >> V[i];
		}
		memset(EventInfo, 0, sizeof(EventInfo));
		for (int i = 0; i < Z; ++i) {
			cin >> n >> e >> a;
			EventInfo[n][0] = e;
			EventInfo[n][1] = a;
		}
		memset(DpMoney, 0, sizeof(DpMoney));
		solve();
		total = 0;
		for (int i = 0; i < 5001; ++i) {
			total += i*DpMoney[i][Y];
		}
		cout << (int)total << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 5008
final_rank: 8

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

template <class T, class U>
vector<T> make_v(U size, const T& init){ return vector<T>(static_cast<size_t>(size), init); }

template<class... Ts, class U>
auto make_v(U size, Ts... rest) { return vector<decltype(make_v(rest...))>(static_cast<size_t>(size), make_v(rest...)); }

template<class T> void chmin(T &a, const T &b){ a = (a < b ? a : b); }
template<class T> void chmax(T &a, const T &b){ a = (a > b ? a : b); }

bool solve(){
    int x, y, z;
    cin >> x >> y >> z;
    if(!x) return 0;
    vector<int> v(x);
    for (auto &&i : v) scanf("%d", &i);
    vector<pair<int, int>> event(y+1);
    for (int i = 0; i < z; ++i) {
        int n, e, a;
        cin >> n >> e >> a;
        event[n] = {e, a};
    }
    auto dp = make_v(y+1, z*100+1, 0.0);
    int mx = 0;
    dp[0][0] = 1.0;
    for (int i = 0; i < y; ++i) {
        int maxx = mx;
        for (int j = 0; j <= mx; ++j) {
            for (int k = 0; k < x; ++k) {
                int ii = min(y, i+v[k]), jj = j;
                if(event[ii].first == 1){
                    ii = min(y, ii+event[ii].second);
                }else if(event[ii].first == 2){
                    jj += event[ii].second;
                    maxx = max(maxx, jj);
                }else if(event[ii].first == 3){
                    jj = max(0, jj-event[ii].second);
                }
                dp[ii][jj] += dp[i][j]/x;
            }
        }
        mx = maxx;
    }
    double ans = 0;
    for (int i = 0; i <= mx; ++i) {
        ans += i*dp.back()[i];
    }
    printf("%.0lf\n", floor(ans));
    return 1;
}

int main() {
    while(solve());
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 5044
final_rank: 9

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

int X, Y, Z;
int V[10];
int e_flag[55], e_value[55];
double dp[55][5500];

int main() {
    while (true) {
        cin >> X >> Y >> Z;
    
        if (X==0 && Y==0 && Z==0) {
            break;
        }
    
        for (int i=0; i<X; i++) {
            cin >> V[i];
        }
    
        for (int i=0; i<=Y; i++) {
            e_flag[i] = -1;
        }
    
        for (int i=0; i<Z; i++) {
            int Ni, Ei, Ai; cin >> Ni >> Ei >> Ai;
            e_flag[Ni] = Ei;
            e_value[Ni] = Ai;
        }
    
        for (int i=0; i<55; i++) {
            for (int j=0; j<5500; j++) {
                dp[i][j] = 0;
            }
        }
    
        dp[0][0] = 1;
    
        for (int i=0; i<Y; i++) {
            for (int j=0; j<5500; j++) {
                for (int k=0; k<X; k++) {
                    int to = i+V[k];
                    
                    if (to>Y) {
                        to = Y;
                    }
                    
                    if (e_flag[to]==-1) {
                        dp[to][j] += dp[i][j]/X;
                    }
                    else if (e_flag[to]==1) {
                        to += e_value[to];
                        
                        if (to>Y) {
                            to = Y;
                        }
                        
                        dp[to][j] += dp[i][j]/X;
                    }
                    else if (e_flag[to]==2 && j+e_value[to]<5500) {
                        dp[to][j+e_value[to]] += dp[i][j]/X;
                    }
                    else if (e_flag[to]==3) {
                        dp[to][max(0, j-e_value[to])] += dp[i][j]/X;
                    }
                }
            }
        }
    
        double ans = 0;
    
        for (int i=0; i<5500; i++) {
            ans += dp[Y][i]*i;
        }
        
        cout << (int)ans << endl;
    }
}
accuracy: 1
time_ms: 110
memory_kb: 5452
final_rank: 17

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

int X, Y, Z;
int V[10];
int e_flag[55], e_value[55];
double dp[70][5500];

int main() {
    while (true) {
        cin >> X >> Y >> Z;
    
        if (X==0 && Y==0 && Z==0) {
            break;
        }
    
        for (int i=0; i<X; i++) {
            cin >> V[i];
        }
    
        for (int i=0; i<Y; i++) {
            e_flag[i] = -1;
        }
    
        for (int i=0; i<Z; i++) {
            int Ni, Ei, Ai; cin >> Ni >> Ei >> Ai;
            e_flag[Ni] = Ei;
            e_value[Ni] = Ai;
        }
    
        for (int i=0; i<70; i++) {
            for (int j=0; j<5500; j++) {
                dp[i][j] = 0;
            }
        }
    
        dp[0][0] = 1;
    
        for (int i=0; i<Y; i++) {
            for (int j=0; j<5500; j++) {
                for (int k=0; k<X; k++) {
                    int to = i+V[k];
                 
                    if (to>=Y || e_flag[to]==-1) {
                        dp[to][j] += dp[i][j]/X;
                    }
                    else if (e_flag[to]==1) {
                        to += e_value[to];
                        dp[to][j] += dp[i][j]/X;
                    }
                    else if (e_flag[to]==2 && j+e_value[to]<5500) {
                        dp[to][j+e_value[to]] += dp[i][j]/X;
                    }
                    else if (e_flag[to]==3) {
                        dp[to][max(0, j-e_value[to])] += dp[i][j]/X;
                    }
                }
            }
        }
    
        double ans = 0;
    
        for (int i=Y; i<70; i++) {
            for (int j=0; j<5500; j++) {
                ans += j*dp[i][j];
            }
        }
        
        cout << (int)ans << endl;
    }
}
accuracy: 1
time_ms: 120
memory_kb: 6048
final_rank: 19

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

int main() {
    int x, y, z, v[4], a[55], b[55];
    while(cin >> x >> y >> z, x){
        for(int i=0;i<x;i++){
            cin >> v[i];
        }
        fill(a,a+y+1,0);
        fill(b,b+y+1,0);
        for(int i=0;i<z;i++){
            int n, e, w;
            cin >> n >> e >> w;
            if(e==1){
                b[n] = w;
            }
            else if(e==2){
                a[n] = w;
            }
            else{
                a[n] = -w;
            }
        }
        double dp[55][5005]{};
        dp[0][0] = 1;
        for(int i=0;i<y;i++){
            for(int j=0;j<=5000;j++){
                for(int k=0;k<x;k++){
                    int ni = min(i+v[k], y);
                    int nj = max(j+a[ni], 0);
                    ni = min(ni+b[ni], y);
                    dp[ni][nj] += dp[i][j]/x;
                }
            }
        }
        double ans = 0;
        for(int i=0;i<=5000;i++){
            ans += dp[y][i]*i;
        }
        cout << int(ans) << endl;
    }
    
    return 0;
}
accuracy: 1
time_ms: 100
memory_kb: 5248
final_rank: 16

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

int main(){
    int x, y, z;
    while(cin >> x >> y >> z, x+y+z){
        vector<int> v(x);
        for(int i = 0; i < x; i++)  cin >> v[i];
        vector<int> e(y+1, 0), a(y+1, 0);
        for(int i = 0; i < z; i++){
            int n;  cin >> n;
            cin >> e[n] >> a[n];
        }
        vector<vector<double>> dp(y+1, vector<double>(5001, 0));
        dp[0][0] = 1.0;
        for(int i = 0; i < y; i++){
            for(int j = 0; j < 5001; j++){
                if(dp[i][j] == 0.0) continue;
                for(int k = 0; k < x; k++){
                    int ni = i+v[k], nj = j;
                    if(ni > y)  ni = y;
                    if(e[ni] == 1)  ni = min(y, ni+a[ni]);
                    else if(e[ni] == 2) nj += a[ni];
                    else if(e[ni] == 3) nj = max(0, nj-a[ni]);
                    dp[ni][nj] += dp[i][j] / x;
                }
            }
        }
        double ans = 0;
        for(int i = 0; i < 5001; i++)   ans += dp[y][i]*i;
        cout << (int)ans << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4928
final_rank: 4

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

#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if(!(p))
#define until(p) while(!(p))

using ll = std::int64_t;
using P = std::tuple<int,int>;

int X, Y, Z;
int V[10];
P event[100];
double dp[100][6000];

double rec(int p, int m){
    if(p >= Y){
        return m;
    }

    if(dp[p][m] >= 0){
        return dp[p][m];
    }

    double ev = 0;

    for(int i=0;i<X;++i){
        int np = p + V[i];

        int e, a;
        std::tie(e, a) = event[np];

        if(e == -1){
            ev += 1. / X * rec(np, m);
        }else if(e == 1){
            ev += 1. / X * rec(np + a, m);
        }else if(e == 2){
            ev += 1. / X * rec(np, m + a);
        }else if(e == 3){
            ev += 1. / X * rec(np, std::max(m - a, 0));
        }
    }

    return dp[p][m] = ev;
}

int main(){
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    while(true){
        std::cin >> X >> Y >> Z;

        if(X == 0){
            break;
        }

        for(int i=0;i<X;++i){
            std::cin >> V[i];
        }

        std::fill(event, event + 100, std::make_tuple(-1, -1));

        for(int i=0;i<Z;++i){
            int N, E, A;
            std::cin >> N >> E >> A;

            event[N] = std::make_tuple(E, A);
        }

        std::fill(&dp[0][0], &dp[0][0] + 100 * 6000, -1);

        double ev = rec(0, 0);
        std::cout << floor(ev) << std::endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 7944
final_rank: 15

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

#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)
#define RFOR(i,a) for(int i=(a); i >= 0; --i)
#define FOE(i,a) for(auto i : a)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define DUMP(x)  cerr << #x << " = " << (x) << endl;
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())
#define BIT_ON(bit, i) (bit & (1LL << i))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());

typedef long long LL;
template<typename T> using V = std::vector<T>;
template<typename T> using VV = std::vector<std::vector<T>>;
template<typename T> using VVV = std::vector<std::vector<std::vector<T>>>;
template<typename T> using VVVV = std::vector<std::vector<std::vector<std::vector<T>>>>;

template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }
template<class T> inline void print(T x) { std::cout << x << std::endl; }
template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }
template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }
template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }
template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

const int INF = 1L << 30;
const double EPS = 1e-9;
const std::string YES = "YES", Yes = "Yes", NO = "NO", No = "No";
const std::vector<int> dy4 = { 0, 1, 0, -1 }, dx4 = { 1, 0, -1, 0 };    // 4近傍（右, 下, 左, 上）
const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };

using namespace std;

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    while (true) {
        int X, Y, Z;
        cin >> X >> Y >> Z;
        if (X + Y + Z == 0) {
            break;
        }

        V<int> v(X), E(Y + 1), A(Y + 1);
        FOR(i, 0, X) {
            cin >> v[i];
        }
        FOR(i, 0, Z) {
            int n;
            cin >> n;
            cin >> E[n] >> A[n];
        }

        VV<double> dp(Y + 1, V<double>(5001, 0));
        dp[0][0] = 1.0;

        double ans = 0.0;
        FOR(p, 0, Y + 1) {
            FOR(m, 0, 5001) {
                if (dp[p][m] == 0) {
                    continue;
                }

                FOR(k, 0, X) {
                    int next_p = p + v[k];

                    // ゴール
                    if (next_p >= Y or (E[next_p] == 1 and next_p + A[next_p] >= Y)) {
                        ans += m * dp[p][m] * (1.0 / X);
                    }
                    // forward
                    else if (E[next_p] == 1) {
                        dp[next_p + A[next_p]][m] += dp[p][m] * (1.0 / X);
                    }
                    // get money
                    else if (E[next_p] == 2) {
                        dp[next_p][m + A[next_p]] += dp[p][m] * (1.0 / X);
                    }
                    // lost money
                    else if (E[next_p] == 3) {
                        dp[next_p][max(0, m - A[next_p])] += dp[p][m] * (1.0 / X);
                    }
                    else {
                        dp[next_p][m] += dp[p][m] * (1.0 / X);
                    }
                }
            }
        }
        print(int(ans));

    }
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4984
final_rank: 6