Problem p00493 (C++) — buggy submission, verdict: Memory Limit Exceeded

#include "stdio.h"
#include "string.h"
#include <iostream>

using namespace std;

pair<int, int> maxw[555];
pair<int, int> minw[555];

long long int dp[500][10][2];
long long int dp2[500][10][2];

char a[555];
char b[555];

int aw[555];
int bw[555];

int main() {
  int m;
  scanf("%s", a);
  scanf("%s", b);
  scanf("%d", &m);
  int l;
  l = strlen(b);
  int lw;
  lw = strlen(a);
  for (int i = 0; i < l; i++) {
    bw[i] = b[i] - '0';
    if (0 <= (i - l + lw)) {
      aw[i] = a[i - l + lw] - '0';
    } else {
      aw[i] = 0;
    }
  }
  int flg = 0;
  maxw[0] = make_pair(3, bw[0] % m);
  if (aw[0] == 0) {
    minw[0] = make_pair(0, 0);
  } else {
    minw[0] = make_pair(3, aw[0] % m);
    flg = 1;
  }
  for (int i = 1; i < l; i++) {
    if (maxw[i - 1].first == 3) {
      if (bw[i] > bw[i - 1]) {
        maxw[i] = make_pair(2, (maxw[i - 1].second * 10 + bw[i]) % m);
      } else if (bw[i] < bw[i - 1]) {
        maxw[i] = make_pair(1, (maxw[i - 1].second * 10 + bw[i]) % m);
      } else {
        maxw[i] = make_pair(-1, 0);
      }
    } else if (maxw[i - 1].first == 2) {
      if (bw[i] < bw[i - 1]) {
        maxw[i] = make_pair(1, (maxw[i - 1].second * 10 + bw[i]) % m);
      } else {
        maxw[i] = make_pair(-1, 0);
      }
    } else if (maxw[i - 1].first == 1) {
      if (bw[i] > bw[i - 1]) {
        maxw[i] = make_pair(2, (maxw[i - 1].second * 10 + bw[i]) % m);
      } else {
        maxw[i] = make_pair(-1, 0);
      }
    } else {
      maxw[i] = make_pair(-1, 0);
    }

    if (flg == 0) {
      if (aw[i] != 0) {
        minw[i] = make_pair(3, aw[i] % m);
        flg = 1;
      } else {
        minw[i] = make_pair(0, 0);
      }
    } else {
      if (minw[i - 1].first == 3) {
        if (aw[i] > aw[i - 1]) {
          minw[i] = make_pair(2, (minw[i - 1].second * 10 + aw[i]) % m);
        } else if (aw[i] < aw[i - 1]) {
          minw[i] = make_pair(1, (minw[i - 1].second * 10 + aw[i]) % m);
        } else {
          minw[i] = make_pair(-1, 0);
        }
      } else if (minw[i - 1].first == 2) {
        if (aw[i] < aw[i - 1]) {
          minw[i] = make_pair(1, (minw[i - 1].second * 10 + aw[i]) % m);
        } else {
          minw[i] = make_pair(-1, 0);
        }
      } else if (minw[i - 1].first == 1) {
        if (aw[i] > aw[i - 1]) {
          minw[i] = make_pair(2, (minw[i - 1].second * 10 + aw[i]) % m);
        } else {
          minw[i] = make_pair(-1, 0);
        }
      } else {
        minw[i] = make_pair(-1, 0);
      }
    }
  }

  for (int i = 0; i < 500; i++) {
    for (int ii = 0; ii < 10; ii++) {
      dp[i][ii][0] = 0;
      dp[i][ii][1] = 0;
    }
  }

  int flh = 0;

  for (int i = 0; i < l; i++) {
    for (int j = 0; j < 500; j++) {
      for (int jj = 0; jj < 10; jj++) {
        dp2[j][jj][0] = 0;
        dp2[j][jj][1] = 0;
      }
    }
    for (int ii = 0; ii < 10; ii++) {
      for (int j = 0; j < 10; j++) {
        if (ii > j) {
          for (int jj = 0; jj < m; jj++) {
            dp2[(jj * 10 + ii) % m][ii][1] += dp[jj][j][0];
          }
        } else if (ii < j) {
          for (int jj = 0; jj < m; jj++) {
            dp2[(jj * 10 + ii) % m][ii][0] += dp[jj][j][1];
          }
        }
      }
    }

    if (aw[i] != bw[i] && flh == 0) {
      flh = 1;
    }

    if (flh != 0) {
      if (flh != 1) {
        if (i == 0) {
          for (int j = aw[i] + 1; j < bw[i]; j++) {
            dp2[j % m][j][0]++;
            dp2[j % m][j][1]++;
          }
        } else if (maxw[i - 1].first == 3) {
          for (int j = 0; j < bw[i]; j++) {
            if (j > bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
            } else if (j < bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
            }
          }
        } else if (maxw[i - 1].first == 2) {
          for (int j = 0; j < bw[i]; j++) {
            if (j < bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
            }
          }
        } else if (maxw[i - 1].first == 1) {
          for (int j = 0; j < bw[i]; j++) {
            if (j > bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
            }
          }
        }

        if (i != 0) {
          if (minw[i - 1].first == 0) {
            if (i == l - 1) {
              for (int j = aw[i]; j < 10; j++) {
                dp2[j % m][j][0]++;
              }
            } else {
              for (int j = aw[i] + 1; j < 10; j++) {
                dp2[j % m][j][0]++;
                dp2[j % m][j][1]++;
              }
            }
          } else if (minw[i - 1].first == 3) {
            for (int j = aw[i] + 1; j < 10; j++) {
              if (j > aw[i - 1]) {
                dp2[(minw[i - 1].second * 10 + j) % m][j][1]++;
              } else if (j < aw[i - 1]) {
                dp2[(minw[i - 1].second * 10 + j) % m][j][0]++;
              }
            }
          } else if (minw[i - 1].first == 2) {
            for (int j = aw[i] + 1; j < 10; j++) {
              if (j < aw[i - 1]) {
                dp2[(minw[i - 1].second * 10 + j) % m][j][0]++;
              }
            }
          } else if (minw[i - 1].first == 1) {
            for (int j = aw[i] + 1; j < 10; j++) {
              if (j > aw[i - 1]) {
                dp2[(minw[i - 1].second * 10 + j) % m][j][1]++;
              }
            }
          }
        }
      } else {
        if (i == 0) {
          for (int j = aw[i] + 1; j < bw[i]; j++) {
            dp2[j % m][j][0]++;
            dp2[j % m][j][1]++;
          }
        } else if (maxw[i - 1].first == 3) {
          for (int j = aw[i] + 1; j < bw[i]; j++) {
            if (j > bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
            } else if (j < bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
            }
          }
        } else if (maxw[i - 1].first == 2) {
          for (int j = aw[i] + 1; j < bw[i]; j++) {
            if (j < bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
            }
          }
        } else if (maxw[i - 1].first == 1) {
          for (int j = aw[i] + 1; j < bw[i]; j++) {
            if (j > bw[i - 1]) {
              dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
            }
          }
        }
        /*
        if(i != 0)
        {
                if(minw[i - 1].first == 0)
                {
                        if(i == l - 1)
                        {
                                for(int j = aw[i]; j < bw[i]; j++)
                                {
                                        dp2[j % m][j][0]++;
                                }
                        }
                        else
                        {
                                for(int j = aw[i] + 1; j < bw[i]; j++)
                                {
                                        dp2[j % m][j][0]++;
                                        dp2[j % m][j][1]++;
                                }
                        }
                }
                else if(minw[i - 1].first == 3)
                {
                        for(int j = aw[i] + 1; j < bw[i]; j++)
                        {
                                if(j > aw[i - 1])
                                {
                                        dp2[(minw[i - 1].second * 10 + j) %
        m][j][1]++;
                                }
                                else if(j < aw[i - 1])
                                {
                                        dp2[(minw[i - 1].second * 10 + j) %
        m][j][0]++;
                                }
                        }
                }
                else if(minw[i - 1].first == 2)
                {
                        for(int j = aw[i] + 1; j < bw[i]; j++)
                        {
                                if(j < aw[i - 1])
                                {
                                        dp2[(minw[i - 1].second * 10 + j) %
        m][j][0]++;
                                }
                        }
                }
                else if(minw[i - 1].first == 1)
                {
                        for(int j = aw[i] + 1; j < bw[i]; j++)
                        {
                                if(j > aw[i - 1])
                                {
                                        dp2[(minw[i - 1].second * 10 + j) %
        m][j][1]++;
                                }
                        }
                }
        }
        */
      }

      flh++;
    }

    for (int j = 0; j < m; j++) {
      for (int jj = 0; jj < 10; jj++) {
        for (int jjj = 0; jjj < 2; jjj++) {
          dp[j][jj][jjj] = dp2[j][jj][jjj] % 10000;
        }
      }
    }
  }

  int all = 0;
  for (int i = 0; i < 10; i++) {
    all = (all + dp[0][i][0]) % 10000;
    all = (all + dp[0][i][1]) % 10000;
  }
  printf("%d\\n", all);

  return 0;
}

Error: MLE

Fixed submission:

#include "stdio.h"
#include "string.h"
#include <iostream>

using namespace std;

int dp[500][500][10][3][3];

char a[555];
char b[555];

char aw[500];
char bw[500];

int main() {
  int m;
  scanf("%s", a);
  scanf("%s", b);
  scanf("%d", &m);
  int l = strlen(b);
  for (int i = 0; i < l; i++) {
    if (i >= l - strlen(b)) {
      aw[i] = a[i - (l - strlen(b))] - '0';
    } else {
      aw[i] = 0;
    }
    bw[i] = b[i] - '0';
  }
  for (int j = 0; j < 500; j++) {
    for (int i = 0; i < 500; i++) {
      for (int ii = 0; ii < 10; ii++) {
        for (int iii = 0; iii < 2; iii++) {
          for (int iiii = 0; iiii < 3; iiii++) {
            dp[j][i][ii][iii][iiii] = 0;
          }
        }
      }
    }
  }
  for (int i = 0; i < 10; i++) {
    for (int ii = 0; ii < 2; ii++) {
      if (i == aw[0]) {
        if (i == 0) {
          dp[0][i % m][i][3][1] = 1;
        } else {
          dp[0][i % m][i][ii][1] = 1;
        }
      } else if (i == bw[0]) {
        dp[0][i % m][i][ii][2] = 1;
      } else if (aw[0] < i && i < bw[0]) {
        dp[0][i % m][i][ii][0] = 1;
      }
    }
  }
  for (int i = 1; i < l; i++) {
    for (int ii = 0; ii < 10; ii++) {
      for (int j = 0; j < 10; j++) {
        if (ii < aw[i]) {
          if (ii < j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][2];
            }
          } else if (ii > j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][2];
            }
          }
        } else if (ii == aw[i]) {
          if (ii == 0) {
            dp[i][0][ii][3][1] = 1;
          } else if (ii < j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][1] += dp[i - 1][jj][j][i % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][1] += dp[i - 1][jj][j][3][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][2];
            }
          } else if (ii > j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][1] +=
                  dp[i - 1][jj][j][(i + 1) % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][1] += dp[i - 1][jj][j][3][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][2];
            }
          }
        } else if (ii == bw[i]) {
          if (ii < j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][3][1];
              dp[i][(jj + ii) % m][ii][i % 2][2] += dp[i - 1][jj][j][i % 2][2];
            }
          } else if (ii > j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][3][1];
              dp[i][(jj + ii) % m][ii][i % 2][2] +=
                  dp[i - 1][jj][j][(i + 1) % 2][2];
            }
          }
        } else if (bw[i] < ii) {
          if (ii < j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][3][1];
            }
          } else if (ii > j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][3][1];
            }
          }
        } else {
          if (ii < j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][3][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][i % 2][2];
            }
          } else if (ii > j) {
            for (int jj = 0; jj < m; jj++) {
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][0];
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] += dp[i - 1][jj][j][3][1];
              dp[i][(jj + ii) % m][ii][i % 2][0] +=
                  dp[i - 1][jj][j][(i + 1) % 2][2];
            }
          }
        }
      }
    }
    for (int j = 0; j < 500; j++) {
      for (int jj = 0; jj < 10; jj++) {
        for (int jjj = 0; jjj < 3; jjj++) {
          for (int jjjj = 0; jjjj < 3; jjjj++) {
            dp[i][j][jj][jjj][jjjj] %= 10000;
          }
        }
      }
    }
  }
  int max = 0;
  for (int i = 0; i < 10; i++) {
    for (int ii = 0; ii < 3; ii++) {
      for (int iii = 0; iii < 3; iii++) {
        max = (max + dp[l - 1][0][i][ii][iii]) % 10000;
      }
    }
  }
  printf("%d\\n", max);
  return 0;
}