如何解决一道用最小步数处理字符串折叠问题？

#include <iostream>
#include <cmath>
#include <time.h>
using namespace std;

const int lenth = 16;
int main()
{  
    srand(time(NULL));
    int a[1000][1000];
    int b[lenth];
    for(int i = 0;i < lenth;++i) {
        b[i] = rand()%10;
    }
    int temp1, temp2, r;
    bool success = false;
    int count = 0;
    for(int j = 2;;++j) {
        temp1 = b[j] / j;
        if(temp1 <= 1) {
            cout << count << endl;
            break;
        }
        temp2 = b[j] % 2;
        if(temp2 > 0) {
            r = j + 1;
        }
        for(int k = 0;k < 1000;++k) {
            for(int l = 0;l < 1000;++l) {
                a[k][l] = 0;
            }
        }
        for(int k = 0;k < r;++k) {
            if(r == j) {
                for(int l = 0;l < temp1;++l) {
                    a[k][l] = b[l];
                }
            }
            else if(r > j) {
                if(k < j) {
                    for(int l = 0;l < temp1;++l) {
                        a[k][l] = b[l];
                    }
                }
                else {
                    for(int l = 0;l < temp2;++l) {
                        a[k][l] = b[l];
                    }
                }
            }
        }
        for(int k = 0;k < r;++k) {
            if(r == j) {
                for(int l = 0;l < temp1;++l) {
                    if(k + 1 < r && l + 1 < temp1 && 0 < k - 1 && l - 1 > 0) {
                        if(a[k][l] == a[k + 1][l] || a[k][l] == a[k - 1][l] || 
                        a[k][l] == a[k][l - 1] || a[k][l] == a[k][l + 1] ||
                        a[k][l] == a[k + 1][l + 1] || a[k][l] == a[k - 1][l - 1]) {
                            success = true;
                                break;
                        }
                    }
                }
                if(success == true) {
                    ++count;
                    break;
                }
            }
            else if(r > j) {
                if(k < j) {
                    for(int l = 0;l < temp1;++l) {
                        if(k + 1 < r && l + 1 < temp1 && 0 < k - 1 && l - 1 > 0) {
                            if(a[k][l] == a[k + 1][l] || a[k][l] == a[k - 1][l] || 
                            a[k][l] == a[k][l - 1] || a[k][l] == a[k][l + 1] ||
                            a[k][l] == a[k + 1][l + 1] || a[k][l] == a[k - 1][l - 1]) {
                            success = true;
                            break;
                            }
                        }
                    }
                
                    if(success == true) {
                        ++count;
                        break;
                    }
                }
            }
            
            else {
                for(int l = 0;l < temp2;++l) {
                    if(k + 1 < j && l + 1 < j && 0 < k - 1 && l - 1 > 0) {
                        if(a[k][l] == a[k + 1][l] || a[k][l] == a[k - 1][l] || 
                        a[k][l] == a[k][l - 1] || a[k][l] == a[k][l + 1] ||
                        a[k][l] == a[k + 1][l + 1] || a[k][l] == a[k - 1][l - 1]) {
                        success = true;
                        break;
                        }
                    }
                }
                if(success == true) {
                    ++count;
                    break;
                }
            }
        }
    }

    return 0;
}