url: https://www.luogu.com.cn/problem/P4343

tag:
二分，模拟

思路：
思路比较简单，根据题目可以知道当n越小时切出来的题目数量越多，根据这个来二分。分别二分出一个最小值和一个最大值。这道题是细节比较 恶心（bushi 多，需要注意的点比较多。第一个是二分的范围，题目只有一个xi的范围是1e-9到1e9，经测试，r开到1e9范围比较小，看了题解之后发现需要开到1e18.然后这里就有一个问题，因为超过了1e9所以变量不能放到main()函数中，只能放到外面当全局变量。然后如果是mid要用long long类型，记得check函数的函数签名中变量的类型也要是long long。第二个细节是l要从1开始，不能从0开始。第三个细节是，题目没有保证说如果其中一个答案比如最小值存在，另外一个答案就会存在，所以对于最小值和最大值都要进行验证。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;
long long n, k, l ,r;
long long p[N];

long long check (long long x)
{
    long long sum = 0, cnt = 0;
    for (int i = 0; i < n; i ++)
    {
        if (p[i] > 0) sum += p[i];
        else sum = max((long long)0, sum + p[i]);
        if (sum >= x)
        {
            sum = 0;
            cnt ++;
        }
    }
    return cnt;
}
int main()
{
    scanf("%lld%lld", &n, &k);
    for (int i = 0; i < n; i ++) scanf("%lld", &p[i]);
    l = 1, r = 1e18;

    while (l < r)
    {
        long long mid = (l + r) >> 1;
        if (check(mid) <= k) r = mid;
        else l = mid + 1;
    }
    long long tmp;
    if (check(l) != k)
    {
        cout << -1 ;
        return 0;
    }
    else tmp = l;
    l = 1, r = 1e18;
    while (l < r)
    {
        long long mid = (l + r + 1) >> 1;
        if (check(mid) >= k) l = mid;
        else r = mid - 1;
    }
    if (check(l) != k)
    {
        cout << -1 ;
        return 0;
    }
    else cout << tmp << ' ' << l;
    return 0;
}

url: https://www.luogu.com.cn/problem/P1115

tag：
最大子数列，Kadane 算法，动态规划

思路：
使用动态规划得方法来求解，用两个变量currentSum，和maxSum，分别来维护以当前位置结尾的最大子段和以及全局的最大子段和。状态转移分别是currentSum = max(a, currentSum + a), maxSum = max(maxSum, currentSum).最后输出maxSum即可。细节：一开始可以先定义为最小值-0x3f3f3f3f这样可以避免漏掉负数，以及因为要求和所以最好开long long避免爆int。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int n;
int main()
{
    scanf("%d", &n);
    long long currentSum = -0x3f3f3f3f, maxSum = -0x3f3f3f3f;
    for (int i = 0; i < n; i ++)
    {
        long long a;
        scanf("%lld", &a);
        currentSum = max(a, currentSum + a);
        maxSum = max(maxSum, currentSum);
    }
    cout << maxSum << endl;
    return 0;
}

url: https://www.luogu.com.cn/problem/P1090

tag:
哈夫曼（Huffman）树 , 优先队列

思路：因为每次合并果子需要的体力值是两堆果子的重量之和，所以为了让总的体力值最小，可以使用贪心的策略，每次都只合并所有堆中重量最小的两堆。因此可以使用优先队列，每次取出两个头节点，res += 两个节点值的和，再将和的值插入到优先队列，重复这个过程直到队列中只有一个值，最后输出res即可。

代码：

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main()
{
    priority_queue<int, vector<int>, greater<int> > heap;
    int n;
    cin >> n;
    for (int i = 0; i < n; i ++)
    {
        int a;
        cin >> a;
        heap.push(a);
    }
    long long res = 0;
    while(heap.size() > 1)
    {
        int a = heap.top();
        heap.pop();
        int b = heap.top();
        heap.pop();
        res += a + b;
        heap.push(a + b);
    }
    cout << res << endl;
    return 0;
}

url: https://www.luogu.com.cn/problem/P1795

tag:
二分

思路：
将每一个以1开头的片段当作一个整体ki，同时用ki表示当前片段数字的个数，那么若干个ki组合起来的片段的最后一个位置的坐标就是对ki求和Si。所以可以先用二分找到一个大于A的最小值，则A就在那个ki当中，然后求一下A距离上一个ki的偏移量，用A减去S(i - 1)，之后进行判断，如果 == 1则说明A处数字为1，否则就是0。

代码：

#include <iostream>  
#include <cstdio>  
using namespace std;  
int main()  
{  
    int n;  
    scanf("%d", &n);  
    while(n --)  
    {  
        int a;  
        scanf("%d", &a);  
        long long l = 0, r = 1e9;  
        while (l < r)  
        {  
            long long mid = (l + r) >> 1;  
            if (((mid * (mid + 1)) / 2) >= a) r = mid;  
            else l = mid + 1;  
        }  
        l --;  
        long long offset = a - (l * (l + 1)) / 2;  
        if (offset == 1) printf("%d\n", 1);  
        else printf("%d\n", 0);  
    }  
    return 0;  
}

安装

在vue ui中的插件处安装

使用

在 store 文件夹下面的 index.js 处

import { createStore } from 'vuex'

export default createStore({
  state: {
  },
  getters: {
  },
  mutations: {
  },
  actions: {
  },
  modules: {
  }
})

state 存放的是变量， getters 存放的是需要由 state 中的变量动态计算生成的变量， mutations 存放的是直接对 state 中变量进行修改的函数， actions 存放的是对 state 的各种更新方式（不能对state进行直接修改）， modules 可以将 state 进行分割，避免代码过长。

在标签中使用变量
示例：

<ul class="navbar-nav" v-if="!$store.state.user.is_login">
    <li class="nav-item">
    <router-link class="nav-link" :to="{name: 'login', params: {}}">登录</router-link>
    </li>
    <li class="nav-item">
    <router-link class="nav-link" :to="{name: 'register', params: {}}">注册</router-link>
    </li>
</ul>
<ul class="navbar-nav" v-else>
    <li class="nav-item">{{ $store.state.user.username }}</li>
</ul>

使用 $store 访问store，user是一个module，所以通过这样的方式来访问user中的is_login变量

在 script 中使用
示例：

import { useStore } from 'vuex';
export default {
  name: 'UserListView',
  components: {
  },
  setup() {
    const store = useStore();
    console.log(store.state.user.username);
  }
}

在外部使用 actions 中的函数需要用到 useStore 这个组件
例如：

setup() {
    const store = useStore();
    const login = () => {
      store.dispatch("login", {
        username: username.value,
        password: password.value,
        succuss() {
          console.log("success");
        },
        error() {
          console.log("error");
        }
      })
    }
    return {
      login
    }
}

这里用 store 来接收 useStore() 返回的对象，使用 store.dispatch 来调用 login 函数， store.dispatch 传了两个参数，第一个是函数名，第二个是数据。

user.js:

import $ from 'jquery';
const ModuleUser = {
    state: {
        id: "",
        username: "",
        photo: "",
        followerCount: 0,
    },
    getters: {
    },
    mutations: {
    },
    actions: {
        login(context, data) {
            console.log(data);
            $.ajax({
                url: "xxx",
                type: "POST",
                data: {
                    username: data.username,
                    password: data.password,
                },
                success(resp) {
                    console.log(resp)
                }
            })
        }
    },
    modules: {

    }
};
export default ModuleUser;

actions中的login函数两个参数，第一个是上下文context，里面有很多自带的api，第二个是数据，可以通过外部使用这个函数时传入。

index.js:

import { createStore } from 'vuex'
import ModuleUser from './user'
export default createStore({
  state: {
  },
  getters: {
  },
  mutations: {
  },
  actions: {
  },
  modules: {
    user: ModuleUser,
  }
})

这里user单独写一个module独立出去，只要在index.js中引入并在modules中添加这个变量即可。

mutations 中的函数需要传两个参数一个是 state 用来访问state中的变量，另外一个是自定义的参数。

mutations: {
    updateUser(state, user) {
        state.id = user.id;
        state.username = user.username;
        state.photot = user.photo;
        state.followerCount = user.followerCount;
        state.access = user.access;
        state.refresh = user.refresh;
        state.is_login = user.is_login;
    },
},

在 actions 中使用 mutations 中的函数示例：

context.commit("updateUser", {
    ...resp,
    access: access,
    refresh: refresh,
    is_login: true,
})

使用 context 中的commit函数，传两个参数，一个是函数名称，另外一个是自定义参数。