Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. Subarray ad minimum

leetcode 209. Subarray ad minimum

Cum hoc loco, primum quod in mentem venit, violenta est enumeratio, quae sequentia conemur enumerare:

Patet violenta enumeratio methodi tempus erit.

Estne igitur modus optimize ut non tempus exeat? Analyse illud:

In enumeratione violenta, dextra ad proximum locum sinistrarum temporum redibit, ac deinde cum sinistra recensebimus.

Gradus specifici enumerationis optimize sunt hi:

In processu supra enumeratione arca nostra caerulea est sicut fenestra illapsa cum magnitudine certafenestra illapsum

Ad fenestras labens nihil aliud est quam vestigia sequentes;

Initium cuiusque fenestrae quaestionis et positio eventus renovatorum non figitur, et condicio certa in casu casu evolvetur.

Secundum methodum fenestrae labens, codice nostro non vacat.

Incomplexitatem temporis sequentis breviter resolvere: e codice O esse videtur²) , sed ex notione fenestrae nostrae delapsa, duo monstratores in eandem partem percurrunt nec recedunt;Tempus complexionis est O (n).

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int ret = INT_MAX;
        int n = nums.size();
        int sum = 0;
        for(int left = 0, right = 0; right < n; right++)//right后移
        {
            //进窗口
            sum += nums[right];
            //判断窗口
            while(sum >= target)
            {
                //符合条件，更新结果
                ret = min(ret,right - left + 1);
                sum -= nums[left];//出窗口
                left++;
            }  
        }
        if(ret == INT_MAX)
            return 0;
        else
            return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2. longissimum substring sine crebris characteribus

leetcode 3. longissimum linea sine crebris characteribus

Primus modus, qui huic quaestioni occurrit, proculdubio enumeratio est, et deinde numerus temporum singulis characteribus apparet;

Invenimus modum recensendi vim brutam posse etiam transire

Estne melior solutio?Analyze fiat scriptor

Estne haec solutio tantum fenestrae lapsus?

Estne tempus complexionis O(n) hoc tempore melius quam violentae enumerationis O(n)?²) Etiam melius

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int n = s.size();
        int hash[128] = { 0 };
        int ret = 0;
        for(int left = 0, right = 0; right < n; right++)
        {
            hash[s[right]]++;//入窗口，先记录当前
            while(hash[s[right]] > 1)//若s[right]重复
            {
                hash[s[left]]--;//出窗口
                left++;
            }
            ret = max(ret,right - left + 1);//更新结果
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. Maximus numerus consecutivorum 1's III

leetcode 1004. Maximus numerus continuos I in III

Argumentum resolvendo, videre possumusQuod 0 potest flipped significat: 0 adhiberi potest ut 1 . Propositum deinde est invenire intervallum, quod continet maximum numerum 1s, et numerum 0's in hoc intervallo excedere k non potest.

Violenta enumeratio methodi huius quaestionis non demonstrabitur. Eamus directe ad fenestram lapsus.


Hoc modo nostro codice praeteribit

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int n = nums.size();
        int zero = 0;//统计0的个数
        int ret = 0;
        for(int left = 0, right = 0; right < n; right++)
        {
            //进窗口，判断是否是0
            if(nums[right] == 0)
                zero++;
            //判断0的个数是否大于k
            while(zero > k)
            {
                //判断是否是0出窗口
                if(nums[left] == 0)
                    zero--;
                left++;
            }
            //更新结果
            ret = max(ret,right-left+1);
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4. Minimum numerus operationum ad redigendum x ad 0

leetcode 1658. Minimum operationum numerus ad redigendum x ad 0

Interrogando legendo, reperire possumus quod sit in latere sinistro et in dextro.
Cuius contrarium est quando difficile

• Invenimus continuum intervallum in ordine, removemus contentum continuum in ordine, et residuum contentum x prorsus est aequale, ergone invenimus situm?
• Hoc continuum intervallum estSumma elementorum ordinata minus x *
• Cum longissimum intervallum continuum in acie invenitur, optimam solutionem invenimus.

Adhuc sicut ante quaestionem, fenestra illapsa utere.

class Solution {
public:
    int minOperations(vector<int>& nums, int x) {
        int ret = 0;
        int total = 0;
        int n = nums.size();
        for(auto e : nums)
            total += e; //求数组的和
        int target = total - x; //target为要找的连续区间的总大小

        if(target < 0)//细节
            return -1;
        if(total == x)
            return n;
            
        int sum = 0;
        for(int left = 0, right = 0; right < n; right++)
        {
            sum += nums[right];//进窗口
            while(sum > target)
            {
                sum -= nums[left];
                left++;
            }
            if(sum == target)//找到目标区间，取长的一个
                ret = max(ret,right - left + 1);
        }
        if(ret == 0)
            return -1;
        else
            return n - ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

5. Fructus cophini

leetcode 904.Fruits in cartallum

Hic titulus tam longus est, quid significat?

Duo tantum cophini sunt, et duo genera fructuum in cophinis esse possunt, et arbores transire non possunt.
Id est longitudinem continui intervalli invenire

Unde scio quot fructus nunc lecta sint? Nullam mensam ---- usus mutant

Invenire possumus consumptionem usurarum tabularum hastarum adhuc satis magnam.

Ex requisitis videri potest quod genus sit minus quam 10⁵, ita recta acie uti possumus + variabilis (record type)

Hoc modo multum emendavit efficientia nostra.

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int n = fruits.size();
        int ret = 0;
        int hash[100000] = { 0 };
        int kinds = 0;
        for(int left = 0, right = 0; right < n; right++)
        {
            if(hash[fruits[right]] == 0)//判断是否是新种类水果
                kinds++;

            hash[fruits[right]]++;//进窗口
            
            while(kinds > 2)//判断总类是否大于2
            {
                hash[fruits[left]]--;//出窗口
                if(hash[fruits[left]] == 0)
                    kinds--;  //去除该种类
                left++;
            }
            ret = max(ret,right - left + 1);
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

6. Reperio omnes litteras anagrammata in filo

leetcode 438. Find omnes litteras anagrammata in filo

Ex analysi quaestionis videre possumus in chorda p chorda invenire (ordo characterum in p chorda turbari potest).
Tunc possumusSubstring mox cuius longitudo = p, et cuius indoles genus ac numerus est = p chorda.。

Ita uti possumus duabus tabulis Nullam ut rationes et numeros characterum in chordis p et chordis respective numerare.

Experiamur primum enumeratione violenta utendo:

Quomodo duae mensae Nullam comparantur?

1. Primo, utere hash1 ad notare numerum generum notarum in p chorda.
2. Percurre s et inveni substring cuius longitudo = p, et characterem currentem reponit.
   a
   b

Violenta enumeratio methodus quidem factibilis est, sed inhabilis est secundum quid.
Cum continuum quaerimus intervallum, illapsa fenestra uti possumus?scriptor experiri

Hoc modo efficientia nostra multo altior erit

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> ret;
        int len = p.size();
        int hash1[128] = { 0 };
        for(auto e: p)
            hash1[e]++;//统计p串的种类
        int n = s.size();
        int hash2[128] = { 0 };//统计子串种类
        int kinds = 0;
        int tmp = 0;
        for(int left = 0,right = 0; right < n ; right++)
        {
            hash2[s[right]]++; //进窗口
            tmp++;//子串长度增加
            if(hash2[s[right]] <= hash1[s[right]])
                kinds++;//"有效字符"种类增加
            if(tmp > len)
            {
                if(hash2[s[left]] <= hash1[s[left]])
                    kinds--;//left位置为“有效字符”，种类减少
                hash2[s[left]]--;
                tmp--;
                left++;
            }
            if(tmp == len)
                if(kinds == len)
                    ret.push_back(left);
        }
        return ret;
        
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

7. Concatenate substrings omnium verborum

leetcode 30. Concatenate substrings omnium verborum

Haec quaestio priori quaestioni similis est, nisi quod notae chordis substituuntur. Ergo adhuc utimur: fenestra illapsum + Nullam mensam ad solvendum quaestionem.

Problema gradibus solvendis:

1. Primum usum hash1 numerare genera chordarum in verbis
2. Fenestella labens utere (cum chordae longitudo fixa sit, potes longitudinem directe salire)
   a
   b.
   c
   Si exire fenestra
   Proventus Renovatio

Sed sola codicis pars praetermissa est.

Hic est codice!

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        vector<int> ret;
        unordered_map<string,int> hash1;
        for(auto& e : words)
            hash1[e]++;//统计要求的字符串种类
        int n = s.size();
        int len = words[0].size();//固定的字符串长度
        int m = words.size();//数组长度
        for(int i=0; i < len; i++)
        {
            unordered_map<string,int> hash2;
            int count = 0;
            for(int left = i, right = i; right <= n -len; right+= len)
            {
                string in = s.substr(right,len);//裁剪字符串
                hash2[in]++;//进窗口
                if(hash2[in] <= hash1[in])
                    count++;//统计当前字符串数量
                if(right - left + 1 > m*len)//判断字符串数量是否大于字符数组
                {
                    string out = s.substr(left,len);
                    if(hash2[out] <= hash1[out])
                        count--;
                    hash2[out]--;//出窗口
                    left += len;
                }
                if(count == m)
                    ret.push_back(left);
            }
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

8. Minimum velamen substring

leetcode 76. Minimum covering substring

Solutio huius quaestionis simillima est praecedenti quaestione. Etiam perquirit omnes notas chordae in chordis s, praeterquam quod minima chordarum inventarum redditur.

Adhuc fenestra illapsa utimur + mensa Nullam solvere.

1. Usus hash1 numerare rationem et numerum characters in T filum
2. Fenestra illapsus: definias incipiens positio sinistra, dextra
   a
   b
   c.

Initium positio et longitudo chordae in codice recenseantur, et in codice nostro supra erit.

class Solution {
public:
    string minWindow(string s, string t) {
        int hash1[128] = { 0 };
        for(auto e : t)
            hash1[e]++;//统计t串的字符种类和数量
        int m = t.size();
        int n = s.size();
        int hash2[128] = { 0 };
        int count = 0;
        int start = 0;
        int len = INT_MAX;
        for(int left = 0, right = 0; right < n; right++)
        {
            hash2[s[right]]++;//进窗口
            if(hash2[s[right]] <= hash1[s[right]])//是否更新有效字符
                count++;
            while(count >= m)//是否出窗口
            {
                if(count == m)//找到符合种类的子串
                {
                    //取长度小的一个
                    int curlen = right - left + 1;
                    if(curlen < len)
                    {
                        start = left;
                        len = curlen;
                    }
                }
                //出窗口
                if(hash2[s[left]] <= hash1[s[left]])
                    count--;
                hash2[s[left]]--;
                left++;
            }
        }
        if(len == INT_MAX)
            return "";
        else
            return s.substr(start,len);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42