Problem:
通勤経路
問題
JOIさんが住むカナダのある都市は，南北方向にまっすぐに伸びる w 本の道路と，東西方向にまっすぐに伸びる h 本の道路により，碁盤の目の形に区分けされている．
南北方向の w 本の道路には，西から順に 1, 2, ... , w の番号が付けられている．また，東西方向の h 本の道路には，南から順に 1, 2, ... , h の番号が付けられている．西から i 番目の南北方向の道路と，南から j 番目の東西方向の道路が交わる交差点を (i, j) で表す．
JOIさんは，交差点 (1, 1) の近くに住んでおり，交差点 (w, h) の近くの会社に車で通っている．車は道路に沿ってのみ移動することができる．JOIさんは，通勤時間を短くするため，東または北にのみ向かって移動して通勤している．また，この都市では，交通事故を減らすために，次のような交通規則が設けられている：
交差点を曲がった車は，その直後の交差点で曲がることは出来ない．
すなわち，交差点で曲がったあとに1ブロックだけ進んで再び曲がることは許されない．このとき，JOIさんの通勤経路は何通り考えられるだろうか．
w と h が与えられたとき，JOIさんの通勤経路の個数を 100000 で割った余りを出力するプログラムを作成せよ．
入力
入力は複数のデータセットからなる．各データセットは1行からなり，空白を区切りとして2個の整数 w, h (2 ≤ w ≤ 100， 2 ≤ h ≤ 100) が書かれている．w は南北方向の道路の本数， h は東西方向の道路の本数を表す．
w, h がともに 0 のとき入力の終了を示す.データセットの数は 5 を超えない．
出力
データセットごとに，JOIさんの通勤経路の個数を 100000 で割った余りを1行に出力する．
入出力例
入力例
3 4
15 15
0 0
出力例
5
43688
1つ目の入力例におけるJOIさんの通勤経路 ( 5 通り)
1つ目の入力例において，JOIさんの通勤経路は図のように 5 通り考えられる．したがって，5を出力する．
2つ目の入力例において，JOIさんの通勤経路は 143688 通り考えられる．したがって，143688 を 100000 で割った余りである 43688 を出力する．
上記問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
#define loop(n) for (int ngtkana_is_geneous = 0; ngtkana_is_geneous < n; ngtkana_is_geneous++)
#define rep(i, begin, end) for(int i = begin; i < end; i++)

#define LOCAL
using std::to_string;
auto to_string(std::string s) -> std::string {
  return '"' + s + '"';
}
auto to_string(char c) -> std::string {
  return "'" + std::string{c} + "'";
}
auto to_string(const char* s) -> std::string {
  return to_string((std::string) s);
}
auto to_string(bool b) -> std::string {
  return (b ? "true" : "false");
}
template <typename T, typename U>
auto to_string(std::pair<T, U> p) -> std::string {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <size_t N>
auto to_string(std::bitset<N> bs) -> std::string {
  std::string res{};
  for (size_t i = 0; i < N; i++)
    res.insert(res.begin(), bs.test(i) ? '1' : '0');
  return res;
}
template <typename T>
auto to_string(T v) -> std::string {
  bool flg = false;
  std::string res = "{";
  for (auto const&x : v) {
    if (flg) res += ", ";
    else flg = true;
    res += to_string(x);
  }
  res += "}";
  return res;
}
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  std::cerr << " " << to_string(H);
  debug_out(T...);
}
#ifdef LOCAL
#define debug(...) std::cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

template <typename T>
T inverse(T a, T m) {
  T u = 0, v = 1;
  while (a != 0) {
    T t = m / a;
    m -= t * a; std::swap(a, m);
    u -= t * v; std::swap(u, v);
  }
  assert(m == 1);
  return u;
}
template <typename T>
class modular {
  private:
    int value;
  public:
    constexpr modular() = default;
    constexpr modular(const modular&) = default;
    constexpr modular(modular&&) = default;
    modular& operator=(const modular&) = default;
    modular& operator=(modular&&) = default;

    template <typename U>
    modular (const U& x) {value = normalize(x);}

    template <typename U>
    static auto normalize(const U& x) {
      int v = static_cast<int>(-mod() <= x && x < mod() ? x : x % mod());
      if (v < 0) v += mod();
      return v;
    }

    auto const& operator()() const { return value; }
    template <typename U>
    explicit operator U() const { return static_cast<U>(value); }
    constexpr static auto mod() { return T::value; }

    auto& operator+=(const modular& other) {
      if ((value += other.value) >= mod()) value -= mod();
      return *this;
    }
    auto& operator-=(const modular& other) {
      if ((value -= other.value) < 0) value += mod();
      return *this;
    }
    template <typename U>
    auto& operator+=(const U& other) {return *this += modular(other); }
    template <typename U>
    auto& operator-=(const U& other) {return *this -= modular(other); }
    auto operator-() const { return modular(-value); }
    auto& operator++() {return *this += 1;}
    auto& operator--() {return *this -= 1;}
    auto  operator++(int) {modular result(*this); operator++(); return result;}
    auto  operator--(int) {modular result(*this); operator--(); return result;}
  
    template <typename U = T>
    auto& operator*=(const modular& rhs) {
      value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
      return *this;
    }
    auto& operator/=(const modular& other) {
      return *this *= modular(inverse(other.value, mod()));
    }
};
template <typename T> struct is_modular : std::false_type {};
template <typename T> struct is_modular <modular<T>> : std::true_type{};
template <typename T> constexpr bool is_modular_v = is_modular<T>::value;

template <typename T> bool operator==(const modular<T>& lhs, const modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const modular<T>& lhs, U rhs) { return lhs == modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const modular<T>& rhs) { return modular<T>(lhs) == rhs; }

template <typename T> bool operator!=(const modular<T>& lhs, const modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const modular<T>& rhs) { return !(lhs == rhs); }

template <typename T> modular<T> operator+(const modular<T>& lhs, const modular<T>& rhs) { return modular<T>(lhs) += rhs; }
template <typename T, typename U> modular<T> operator+(const modular<T>& lhs, U rhs) { return modular<T>(lhs) += rhs; }
template <typename T, typename U> modular<T> operator+(U lhs, const modular<T>& rhs) { return modular<T>(lhs) += rhs; }

template <typename T> modular<T> operator-(const modular<T>& lhs, const modular<T>& rhs) { return modular<T>(lhs) -= rhs; }
template <typename T, typename U> modular<T> operator-(const modular<T>& lhs, U rhs) { return modular<T>(lhs) -= rhs; }
template <typename T, typename U> modular<T> operator-(U lhs, const modular<T>& rhs) { return modular<T>(lhs) -= rhs; }

template <typename T> modular<T> operator*(const modular<T>& lhs, const modular<T>& rhs) { return modular<T>(lhs) *= rhs; }
template <typename T, typename U> modular<T> operator*(const modular<T>& lhs, U rhs) { return modular<T>(lhs) *= rhs; }
template <typename T, typename U> modular<T> operator*(U lhs, const modular<T>& rhs) { return modular<T>(lhs) *= rhs; }

template <typename T> modular<T> operator/(const modular<T>& lhs, const modular<T>& rhs) { return modular<T>(lhs) /= rhs; }
template <typename T, typename U> modular<T> operator/(const modular<T>& lhs, U rhs) { return modular<T>(lhs) /= rhs; }
template <typename T, typename U> modular<T> operator/(U lhs, const modular<T>& rhs) { return modular<T>(lhs) /= rhs; }

template<typename T, typename U>
modular<T> pow (const modular<T>& a, U b) {
  assert(b >= 0);
  modular<T> x = a, ret = 1;
  for (; b > 0; b /= 2) {
    if (b % 2 == 1) ret *= x;
    x *= x;
  }
  return ret;
}

template <typename T>
std::string to_string(const modular<T>& a) {
  return std::to_string(a());
}
template <typename T>
auto operator<<(std::ostream& os, const T& a)
  -> std::enable_if_t<is_modular_v<T>, std::ostream&>{
    return os << a();
  }
template <typename T>
auto operator>>(std::istream& is, T& a)
  -> std::enable_if_t<is_modular_v<T>, std::istream&> {
  long long x; is >> x;
  a = T(x);
  return is;
}

/*
using ModType = int;

struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/

template <typename T>
auto make_vector(size_t sz, T t) {
  return std::vector<T>(sz, t);
}
template <size_t N, typename T, typename U, std::enable_if_t<
  N == 1, std::nullptr_t> = nullptr>
auto make_higher_vector(size_t sz, U u) {
  return make_vector(sz, T(u));
}
template <size_t N, typename T, std::enable_if_t<
  N == 1, std::nullptr_t> = nullptr>
auto make_higher_vector(size_t sz) {
  return std::vector<T>(sz);
}
template <size_t N, typename T, typename... Args, std::enable_if_t<
  N != 1, std::nullptr_t> = nullptr>
auto make_higher_vector(size_t a, Args... args) {
  return make_vector(a, make_higher_vector<N - 1, T>(args...));
}
template <typename T, typename Size_t>
auto& at(T& t, Size_t i) {
  return t.at(i);
}
template <typename T, typename Size_t, typename... Args>
auto& at(T& t, Size_t i, Args... args) {
  return at(t.at(i), args...);
}

constexpr int md = 100'000;
using mint = modular<std::integral_constant<std::decay_t<decltype(md)>, md>>;


int main()
{
  std::cin.tie(0); std::cin.sync_with_stdio(false);
  while (true)
  {
    int h, w; std::cin >> h >> w;
    if (h == 0 && w == 0) return 0;
    h--, w--;
    auto dp = make_higher_vector<2, mint>(h + 1, w + 1, 0);
    auto ep = make_higher_vector<2, mint>(w + 1, h + 1, 0);
    rep(i, 0, h + 1) at(dp, i, 0) = 1;
    rep(j, 0, w + 1) at(ep, j, 0) = 1;
    rep(i, 1, h + 1) rep(j, 1, w + 1)
    {
      rep(k, 0, i - 1) at(dp, i, j) += at(ep, j, k);
      rep(k, 0, j - 1) at(ep, j, i) += at(dp, i, k);
    }
    at(dp, h, w) += at(ep, w, h - 1);
    at(ep, w, h) += at(dp, h, w - 1);
    std::cout << at(dp, h, w) + at(ep, w, h) << std::endl;
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3316
final_rank: 1

code_snippet: #include<iostream>
#include<string>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<list>
#include<random>
#include<iomanip>
#include<vector>
#include<functional>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<unordered_map>
#include<time.h>
#define rep(i,a,n) for (int (i)=(a);(i)<(n);(i)++)
//#define int long long
using namespace std;
typedef long long ll;
typedef long double ld;
using namespace std;
int h, w;
int dp[100][100][2][100];//???????¨??????±??????????????????????????§?????????????????\??????
int solve(int i, int j, bool dir, int dis) {
	if (i == h - 1 && j == w - 1)
		return 1;
	if (dp[i][j][dir][dis] != -1)
		return dp[i][j][dir][dis];
	int ans = 0;
	for (int z = 0; z < 2; z++) {
		int x = (z == 0 ? i + 1 : i), y = (z == 1 ? j + 1 : j);
		if (x == h || y == w) continue;
		if (dis < 2 && (int)dir != z) continue;
		ans += solve(x, y, z, z == (int)dir ? dis + 1 : 1);
	}
	return (dp[i][j][dir][dis] = ans % 100000);
}
signed main() {
	while (cin >> w >> h&&w != 0 && h != 0) {
		for (int i = 0; i < h; i++) {
			for (int j = 0; j < w; j++) {
				for (int dir = 0; dir < 2; dir++) {
					for (int dis = 0; dis < 100; dis++)
						dp[i][j][dir][dis] = -1;
				}
			}
		}
		cout << (solve(0, 1, 1, 2) + solve(1, 0, 0, 2)) % 100000 << endl;
	}
}
accuracy: 1
time_ms: 30
memory_kb: 10896
final_rank: 5

code_snippet: #include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define LL long long
static const LL INF = 1<<24;
static const LL LL_INF = 1<<60;
static const int mod = 1e+5;
static const int MAX_N = 200;
int dx[]={0,1};
int dy[]={1,0};
using namespace std;


int w,h;
LL mem[MAX_N][MAX_N][3][3][3][3];
LL cal(int x,int y,int px,int py,int ppx,int ppy){
    LL res=0;
    if(mem[x][y][px][py][ppx][ppy]!=0)return mem[x][y][px][py][ppx][ppy];
    if(x>=w||y>=h)return 0;
    if(x==w-1&&y==h-1)return 1;
    FOR(i,0,1){
        if(x==0&&y==0)res+=cal(x+dx[i],y+dy[i],dx[i],dy[i],px,py);
        else{
            if(px!=ppx&&py!=ppy&&px!=dx[i]&&py!=dy[i])continue;
            res+=cal(x+dx[i],y+dy[i],dx[i],dy[i],px,py)%mod;
        }
    }
    return mem[x][y][px][py][ppx][ppy]=res%mod;
}

int main(){
    while(1){
        memset(mem,0,sizeof(mem));
        cin>>w>>h;
        if(w==0&&h==0)break;
        cout<<cal(0,0,0,0,0,0)<<endl;
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 26496
final_rank: 3

code_snippet: #include <cstdio>
#include <algorithm>
using namespace std;
long long mod(long long a){
	return a%100000;
}
long long dp[101][101][101][2]={},ans=0;/*0が縦、1が横*/
int main(){
		while(1){
			for(int i=0;i<101;i++){
				for(int j=0;j<101;j++){
					for(int k=0;k<101;k++){
						for(int h=0;h<2;h++){
							dp[i][j][k][h]=0;
						}
					}
				}
			}
	int c,d;
		scanf("%d %d",&c,&d);
		if(c==0){
			break;
		}
	for(int i=2;i<101;i++){
		dp[1][i][i-1][0]=1;
	}
	for(int i=2;i<101;i++){
		dp[i][1][i-1][1]=1;
	}
	for(int i=2;i<c+1;i++){
		for(int j=2;j<d+1;j++){
			for(int h=1;h<max(i,j);h++){
				if(h!=1){
					dp[i][j][h][0]=mod(dp[i][j-1][h-1][0]);
					dp[i][j][h][1]=mod(dp[i-1][j][h-1][1]);
				}else{
					if(i==2 && j==2){
						dp[2][2][1][0]=1;
						dp[2][2][1][1]=1;
					}else{
						for(int y=2;y<=max(i,j-1);y++){
							dp[i][j][h][0]+=mod(dp[i][j-1][y][1]);
							dp[i][j][h][1]+=mod(dp[i-1][j][y][0]);
						}
					}
				}
			}
		}
	}
	for(int y=1;y<=max(c,d);y++){
		ans+=mod(dp[c][d][y][0])+mod(dp[c][d][y][1]);
		ans=mod(ans);
	}
	printf("%lld\n",mod(ans));
      ans=0;
	}
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 17124
final_rank: 4

code_snippet: #include<vector>
#include<list>
#include<algorithm>
#include<iostream>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
int f(int a[][100][100],int x,int y,int w,int h,int p,int q){
  if(x==w||y==h)
    return (p&1)==(q&1)||(p&2)==(q&2);
  else{
    if((p&1)==(q&1)||(p&2)==(q&2))
      return (f(a,x+1,y,w,h,1,p)+f(a,x,y+1,w,h,2,p))%100000;
    else{
      if(a[(p-1+(w-x>h-y))%2][w-x<h-y?w-x:h-y][w-x>h-y?w-x:h-y]==0)
	a[(p-1+(w-x>h-y))%2][w-x<h-y?w-x:h-y][w-x>h-y?w-x:h-y]=f(a,x+!!(p&1),y+!!(p&2),w,h,p,p);
      return a[(p-1+(w-x>h-y))%2][w-x<h-y?w-x:h-y][w-x>h-y?w-x:h-y];
    }
  }
}
int main(){
  int a[3][100][100],w,h;
  memset(a,0,sizeof(a));
  for(h=2;h<101;h++)
    for(w=h;w<101;w++)
      a[2][h][w]=f(a,1,1,h,w,3,3);
  while(cin>>w>>h&&w+h)
    cout<<a[2][w<h?w:h][w>h?w:h]<<endl;
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 928
final_rank: 2