Question

计算长度为n的字符串的长度为4的子序列，该字符串可以被9整除。

例如，如果输入字符串是9999 那么cnt = 1

我的方法与Brute Force类似，需要O（n ^ 3）。比这更好的方法吗？

Answer 1

如果你想检查一个数字是否可被9整除，你最好看here。

我将简要介绍该方法：

checkDividedByNine(String pNum) :
If pNum.length < 1
   return false
If pNum.length == 1
   return toInt(pNum) == 9;
Sum = 0
For c in pNum:
    Sum += toInt(pNum)
return checkDividedByNine(toString(Sum))

因此，您可以将运行时间减少到小于O（n ^ 3）。

修改如果你需要非常快速的算法，你可以使用预处理来保存每个可能的4位数字，如果它可以被9整除。（内存中将花费你10000）

编辑2： 更好的方法：你可以使用动态编程：

对于长度为N的字符串S：

D [i，j，k] =字符串S [i..N]中长度为j的子序列的数量，它们的值模9 == k。

其中0 <= k <= 8,1 <＆lt; = j <= 4,1 <= i <= N。

D[i,1,k] = simply count the number of elements in S[i..N] that = k(mod 9). D[N,j,k] = if j==1 and (S[N] modulo 9) == k, return 1. Otherwise, 0. D[i,j,k] = max{ D[i+1,j,k], D[i+1,j-1, (k-S[i]+9) modulo 9]}.

你返回D [1,4,0]。

你得到一张大小的桌子 - N x 9 x 4.

因此，假设计算模数为O（1），整体运行时间为O（n）。

Answer 2

~~假设子序列必须由连续数字组成，您可以从左向右扫描，跟踪读取的最后4位数的顺序。这样，您可以进行线性扫描并只需应用可分性规则。~~

如果数字不一定是连续的，那么您可以使用查找表进行一些处理。我们的想法是，您可以创建一个名为table的3D数组，table[i][j][k]是指向i之前的j位数之和，以便总和留下余数当除以9时k的大小。表格本身的大小为45n（i从0到4，j从0到n-1，k从0到8）。

对于递归，每个table[i][j][k]条目依赖于table[i-1][j-1][x]和table[i][j-1][x]从0到8的所有x。因为每个条目更新需要恒定时间（至少相对）到n），这应该让你获得O（n）运行时。

Answer 3

这个怎么样：

/*NOTE: The following holds true, if the subsequences consist of digits in contagious locations */ 

public int countOccurrences (String s) {
    int count=0;
    int len = s.length();
    String subs = null;
    int sum;

    if (len < 4)
        return 0;
    else {
        for (int i=0 ; i<len-3 ; i++) {
            subs = s.substring(i, i+4);
            sum = 0;

            for (int j=0; j<=3; j++) {
                sum += Integer.parseInt(String.valueOf(subs.charAt(j)));
            }

            if (sum%9 == 0)
                count++;
        }           
        return count;
    }   
}

Answer 4

以下是基于上述使用查找表的方法

的上述问题的完整工作代码

int fun(int h)
{
return (h/10 + h%10);
}

int main()
{
int t;
scanf("%d",&t);
int i,T;
for(T=0;T<t;T++)
{
    char str[10001];
    scanf("%s",str);        
    int len=strlen(str);
    int arr[len][5][10];
    memset(arr,0,sizeof(int)*(10*5*len));

    int j,k,l;
        for(j=0;j<len;j++)
            {
              int y;
                y=(str[j]-48)%10;
                arr[j][1][y]++;
            }



        //printarr(arr,len);    





        for(i=len-2;i>=0;i--)   //represents the starting index of the string
            {


                    int temp[5][10];
                    //COPYING ARRAY
                    int a,b,c,d;
                    for(a=0;a<=4;a++)
                    for(b=0;b<=9;b++)
                    temp[a][b]=arr[i][a][b]+arr[i+1][a][b];


            for(j=1;j<=4;j++)   //represents the length of the string
                {
                for(k=0;k<=9;k++)   //represents the no. of ways to make it
                    {

                        if(arr[i+1][j][k]!=0)
                          {
                          for(c=1;c<=4;c++)
                            {
                              for(d=0;d<=9;d++)
                                 {
                            if(arr[i][c][d]!=0)
                                 {
                                int h,r;
                                r=j+c;
                                if(r>4)
                                continue;
                                h=k+d;                      
                                h=fun(h);
                                if(r<=4)
                                  temp[r][h]=( temp[r][h]+(arr[i][c][d]*arr[i+1][j][k]))%1000000007;
                              }}}
                        }






                    //copy back from temp array

                    }
                }
                for(a=0;a<=4;a++)
                    for(b=0;b<=9;b++)
                    arr[i][a][b]=temp[a][b];
            }








printf("%d\n",(arr[0][1][9])%1000000007);


}


    return 0;
}

计算长度为4的子序列可被9整除

4 个答案: