class Solution {
public:
    int numSub(string s) {
        long long count = 0;
        int ret = 0;
        // //子串为 "1"
        // for(char ch : s){
        //     if(ch == '1')
        //     count = count % (10e9 + 7) + 1;
        // }
        // for(int i = 0;i < s.size()-1;i++){
        //     if(s.substr(i,2))
        // }
        for(int len = 1;len <= s.size();len++){
            string model(len,'1');
            for(int i = 0;i <= s.size()-len;i++){
                if(s.substr(i,len) == model){
                    count = count % 1000000007 + 1;
                }
            }
        }
        ret = count % 1000000007;
        return ret;
    }
};

时间复杂度为 O（n^2)，所以当数组特别特别长的时候，循环非常的难

我换了一种方法。将字符串每次遇到 0 都切割成连续为 1 的子串，统计每个子串出现的次数，并且计算每个子串含1的子串个数（等差数列求和 n（n+1）/2)
总的子串个数 = 每个子串的子串个数 * 子串出现的次数

class Solution {
public:
    int numSub(string s) {
        map<int,int> my_map;
        //第一个int统计连续1的字符串的长度，第二个int统计这样的子串的出现次数
        int i = 0;
        int ret = 0;
        long long ans = 0;
        while(i < s.size()){
            int len = 0;
            while(s[i] == '1'){
                ++len;  
                ++i;              
            }
            my_map[len]++;
            while(s[i] == '0')
            ++i;
        }
        for(auto it = my_map.begin();it != my_map.end();it++){
            ans += getCount(it->first) * it->second;
            ans %= 1000000007;
        }
        ret = ans % 1000000007;
        return ret;
    }
    int getCount(int n){
        int ret = 0;
        for(int i = 1;i <= n;i++){
            ret += i;
        }
        return ret;
    }
};

这个方法遇到下面的例子会导致堆栈溢出。

别人的写法
等差数列求和那一步真的是神妙。

class Solution {
public:
    int numSub(string s) {
        int mod = 1e9+7;
        int count = 0,ret = 0;
        for(int i = 0;i < s.size();++i){
            if(s[i] == '1'){
                count++;
                ret = (ret + count) % mod;
                //这个等差数列求和写的真好
            }
            else{
                count = 0;
            }
        }
        return ret;
    }
};