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

突然想到一个数学问题，一串数字经过折叠后，可能会出现连连看的情况，那么如何用最小步数判断这串数字经过不同的折叠后有多少种会出现连连看的情况？

#include <iostream>
#include <cmath>
#include <time.h>
using namespace std;
 
const int lenth = 100;
int main()
{ 
    srand(time(NULL));
    int a[1000][1000];
    int b[lenth];
    for(int i = 0;i < lenth;++i) {
        b[i] = rand()%10;
        cout << b[i] << " ";
    }
    cout << endl;
    int temp1, temp2, r;
    bool success;
    int count = 0;
    int n;
    for(int j = 2;;++j) {
        success = false;
        temp1 = lenth / j;
        if(temp1 <= 1) {
            cout << count << endl;
            break;
        }
        temp2 = lenth % j;
        r = j;
        if(temp2 > 0) {
            r = j + 1;
        }
        
        for(int k = 0;k < 1000;++k) {
            for(int l = 0;l < 1000;++l) {
                a[k][l] = -1;
            }
        }
        n = 0;
        for(int k = 1;k <= r;++k) {
            if(r == j) {
                for(int l = 1;l <= temp1;++l) {
                    a[k][l] = b[n*temp1 + l-1];
                    cout << a[k][l] << " ";
                }
                cout << endl;
                ++n;
            }
            else if(r > j) {
                if(k < r) {
                    for(int l = 1;l <= temp1;++l) {
                        a[k][l] = b[n*temp1 + l-1];
                        cout << a[k][l] << " ";
                    }
                    cout << endl;
                    ++n;
                }
                else {
                    for(int l = 1;l <= temp2;++l) {
                        a[k][l] = b[n*temp1 + l-1];
                        cout << a[k][l] << " ";
                    }
                    cout << endl;
                    ++n;
                }
            }
        }
        for(int k = 1;k <= r;++k) {
            if(r == j) {
                for(int l = 1;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]||
                        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 = 1;l <= temp1;++l) {
                        if(k + 1 <= j && 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]||
                               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 = 1;l <= temp2;++l) {
                    if(k + 1 <= k && l + 1 <= temp2 && 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]||
                           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;
}