2022-04-29每日刷题打卡

2022-04-29每日刷题打卡

代码源——每日一题

吃糖果 - 题目 - Daimayuan Online Judge

桌子上从左到右放着 n 个糖果。糖果从左到右编号，第 i 块糖果的重量为 wi。小明和小红要吃糖果。

小明从左边开始吃任意数量的糖果。（连续吃，不能跳过糖果）

小红从右边开始吃任意数量的糖果。（连续吃，不能跳过糖果）

当然，如果小明吃了某个糖果，小红就不能吃它（反之亦然）。

他们的目标是吃同样重量的糖果，请问此时他们总共最多能吃多少个糖果？

输入格式

第一行包含一个整数 n，表示桌上糖果的数量。

第二行包含 n 个整数 w1,w2,…,wn，表示糖果从左到右的重量。

输出格式

一个整数，表示小明和小红在满足条件的情况下总共可以吃的糖果的最大数量。

数据范围

1≤n≤2∗10^{5,1≤wi≤10}4

输入样例

9
7 3 20 5 15 1 11 8 10

输出样例

7

这题翻译成人话就是，两个人一个从左往右吃糖果，一个从右往左吃糖果，他们俩人吃的糖果重量要一样，问他们两人最多可以吃多少糖果。其实就是说，从左往右的连续和与从右往左的连续和相等的情况下，这两个连续和一共用了多少个数（数量小于等于n）。

那我们可以从左往右先算一遍前缀和，用哈希表记录得到这个前缀和用了多少数，然后再从右往左算一遍后缀和，每次看一下计算的后缀和是否有在哈希表中出现过，如果出现过，就更新一下个数的最大值。注意，当两个序列的个数和大于n时就要结束计算了。

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>

#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;

inline int read() {
    int x = 0; char ch = getchar();
    while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
    return x;
}

inline void write(int x) {
    if (x > 9) write(x / 10);
    putchar(x % 10 | '0');
}

int main()
{
	int n;
	n=read();
	map<ll, int>alice, bob;
	ll sum = 0, len = 0;
	vector<ll>v(n);
	for (int i = 0; i < n; i++)
	{
		v[i]=read();
		sum += v[i];
		alice[sum] = i + 1;
	}
	sum = 0;
	for (int i = n - 1; i >= 0; i--)
	{
		sum += v[i];
		if (alice[sum] != 0 && alice[sum] + n - i <= n)
		{
			len = alice[sum] + n - i;
		}
	}
	write(len);
    return 0;
}

力扣——字典树

139. 单词拆分

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true 因为 “leetcode” 可以由 “leet” 和 “code” 拼接成。

提示：

1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s 和 wordDict[i] 仅有小写英文字母组成
wordDict 中的所有字符串 互不相同

先把wordDict的元素都存入字典树中，然后用字符串s在字典树里找，初始下标为start，如果找到了有以当前位置为结尾的字符串，我们就把s切开，从设置下一个位置为start开始重新在字典树里找。如果在找的过程中，在字典树找不到了，说明不能以这个start为起点，我们返回false，并回到上一层（回溯），然后继续上一层之前的位置继续在字典树里找，找下一个以我们找到的位置为结尾的字符串。

当start为s的末尾时，说明我们已经找到了所有的字符串，这些字符串可以组合成s，返回true，反之我们输出false。

const int N=1e4;
class Solution {
public:
    int f[N][26],cnt[N],idx=1;
    string str;
    int n;
    unordered_map<int,int>mymap;
    void insert(string s)
    {
        int p=1;
        for(auto i:s)
        {
            int j=i-'a';
            if(f[p][j]==0)f[p][j]=++idx;
            p=f[p][j];
        }
        cnt[p]=1;
    }
    
    bool dfs(int p,int start)
    {
        if (mymap[start] != 0)return false;
        else if (start - 1 == n)return true;
        int ans = p;
        bool flag = false;
        for (int i = start; i <= n; i++)
        {
            int j = str[i - 1] - 'a';
            if (f[ans][j] == 0)break;
            ans = f[ans][j];
            if (cnt[ans] != 0)
            {
                flag = (flag || dfs(1,i+1));
                if (flag)return flag;
            }
        }
        mymap[start] = 1;
        return false;
    }

    bool wordBreak(string s, vector<string>& wordDict) {
        memset(f,0,sizeof f);
        memset(cnt,0,sizeof cnt);
        idx=1;
        str=s;
        n=str.size();
        for(auto i:wordDict)insert(i);
        return dfs(1,1);
    }
};