<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[JWind的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/keylamy</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; keylamy]]></copyright><item><title><![CDATA[Leetcode-字典树]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/99953166</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/99953166</guid><author>keylamy</author><pubDate>Wed, 21 Aug 2019 17:55:23 +0800</pubDate><description><![CDATA[720.Longest Word in Dictionary
字典树的模板题
用链表 64 ms	32.1 MB
class Solution {
public:
    struct Node{
        bool is;
        Node* vec[26];
        Node(){
            is=false;
            for(int i=0...]]></description><category></category></item><item><title><![CDATA[Leetcode-二分查找]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/99703684</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/99703684</guid><author>keylamy</author><pubDate>Mon, 19 Aug 2019 23:18:02 +0800</pubDate><description><![CDATA[69.Sqrt(x)
套模板
class Solution {
public:
    long long mySqrt(long long x) {
        long long l=0,r=x;
        while(l&lt;r){
            long long m=(l+r+1)&gt;&gt;1;
            if(m&lt;=x/m) l=m;
 ...]]></description><category></category></item><item><title><![CDATA[102263 - ArabellaCPC 2019（部分）解题报告]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/99689161</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/99689161</guid><author>keylamy</author><pubDate>Sat, 17 Aug 2019 13:52:56 +0800</pubDate><description><![CDATA[link
A - Is It Easy ?
easy
#include&lt;bits/stdc++.h&gt;
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int N=1e5+5;
ll n,k;
 
int main(){
    cin&gt;&gt;n&gt;&gt;k;
    co...]]></description><category></category></item><item><title><![CDATA[Python入门（一）]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/98592537</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/98592537</guid><author>keylamy</author><pubDate>Fri, 09 Aug 2019 09:51:42 +0800</pubDate><description><![CDATA[Python是解释型语言，运行速度较慢，优点在于简洁。
Python源码不能加密，也就是发布Python应用程序就相当于发布了它的源码，但是可以通过卖服务的形式发布
字符串
str='你好'
print(str)
print(str[0:1])

输出
你好
你

字典
d={
    "name":"Alan",
    "age":12,
    1:"level_1"
}
print(d.k...]]></description><category></category></item><item><title><![CDATA[LeetCode 127. Word Ladder]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/98222356</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/98222356</guid><author>keylamy</author><pubDate>Fri, 02 Aug 2019 18:34:29 +0800</pubDate><description><![CDATA[LeetCode 127. Word Ladder
要点：

转化为unordered_set来做，因为它比map、vector的搜索更快，unordered_set的底层是基于哈希的，所以对于频繁的搜索，插入，删除是很有利的。
构图不需要从BFS之前就进行，因为不是每一个点都需要构图，而且每个点只访问一次，所以没必要全图保存，有利于降低时间复杂度。假如是需要频繁访问已访问点，还是全图构造保存比较...]]></description><category></category></item><item><title><![CDATA[A Digital Satire of Digital Age]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/97613711</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/97613711</guid><author>keylamy</author><pubDate>Sun, 28 Jul 2019 13:25:35 +0800</pubDate><description><![CDATA[A Digital Satire of Digital Age
完全被自己蠢到气哭
明确对于每一组输入，要记录的有天枰底部，作为天枰位置的标记，还有天枰上的字符串（有可能是空）
天枰的位置有三种情况，各建三个字符数组表示它们，并且注意赋值完之后要重置。
好了，也不知道还能说什么了，直接上代码吧
#include &lt;bits/stdc++.h&gt;
using namespace std;
...]]></description><category></category></item><item><title><![CDATA[UVALive-4855 Hyper Box]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/97560104</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/97560104</guid><author>keylamy</author><pubDate>Sat, 27 Jul 2019 22:19:57 +0800</pubDate><description><![CDATA[思路：
是斐波那契数的不用管，不是斐波那契数的，需要把它拆开成多个斐波那契数，找到输入数字的小于它的最大的斐波那契数，减去它，再找减去后的数字的小于它的最大的斐波那契数，减去它，不断循环，直到减去的数字本身是个斐波那契数为止。
因为下面的证明要多次用到“小于那个非斐波那契数的最大的斐波那契数”，姑且先记为A。
从A开始减的道理是，一个非斐波那契数，最少需要两个斐波那契数相加才能组成。假如一个非斐波...]]></description><category></category></item><item><title><![CDATA[Codeforces 1187E Tree Painting]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/97159312</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/97159312</guid><author>keylamy</author><pubDate>Wed, 24 Jul 2019 20:02:23 +0800</pubDate><description><![CDATA[Codeforces 1187E Tree Painting
思路是换根，对于一棵树，从它的树根开始上色，那么它的下一个上色点只能是它的孩子节点，对于先上哪个孩子节点是不影响的，因为各孩子都已经不连通，所以，对于一棵定根树，从它的树根开始上色，它的答案只有一种。枚举每个节点换成树根的情况，找到能获得的点数的最大值，就是答案。
在某种状态下，把树根（记作A）换到它的一个孩子节点（记作B）时，因为是从...]]></description><category></category></item><item><title><![CDATA[GoLang入门D6]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/96422349</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/96422349</guid><author>keylamy</author><pubDate>Sun, 21 Jul 2019 09:52:23 +0800</pubDate><description><![CDATA[今天学习函数

函数参数用值传递的形式
允许多值返回，若只有单值，可以不声明
不允许函数嵌套


]]></description><category></category></item><item><title><![CDATA[Codeforces Educational Codeforces Round 67 (Rated for Div. 2) D. Subarray Sorting]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/96474776</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/96474776</guid><author>keylamy</author><pubDate>Fri, 19 Jul 2019 10:10:04 +0800</pubDate><description><![CDATA[codeforces Educational Codeforces Round 67 (Rated for Div. 2) D. Subarray Sorting

考虑目标数组b[i]是如何组成的，在a[ai]a[ai]a[ai]处找到第一个等于b[i]b[i]b[i]的，然后再在[0,ai][0,ai][0,ai]中找到最小值，若最小值还要小于b[i]b[i]b[i]则不可能使b[i]b[i]...]]></description><category></category></item><item><title><![CDATA[GoLang入门D5]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/96422089</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/96422089</guid><author>keylamy</author><pubDate>Thu, 18 Jul 2019 08:21:09 +0800</pubDate><description><![CDATA[今天简单做一些练习

建立一个程序统计字符串里的字符数量：
asSASA ddd dsjkdsjs dk
同时输出这个字符串的字节数。提示： 看看unicode/utf8 包。

PS C:\Windows\system32&gt; go doc unicode/utf8
package utf8 // import "unicode/utf8"

Package utf8 implements ...]]></description><category></category></item><item><title><![CDATA[GoLang入门D4]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/96270364</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/96270364</guid><author>keylamy</author><pubDate>Wed, 17 Jul 2019 10:36:44 +0800</pubDate><description><![CDATA[今天学一些内建函数的应用
有一些函数是预定义的，不需要引用任何包就可以调用,这就是内建函数
array
package main

import (
	"fmt"
)

func main() {
	var a [3]int
	b := [3]int{1, 8, 9}
	for i := 0; i &lt; len(a); i++ {
		fmt.Print(b[i])
	}
	fmt.Print...]]></description><category></category></item><item><title><![CDATA[大数]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/89646305</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/89646305</guid><author>keylamy</author><pubDate>Tue, 16 Jul 2019 14:43:53 +0800</pubDate><description><![CDATA[C++：
&nbsp;&nbsp;&nbsp;&nbsp;32-bit int的最大值可以表示为0x7FFFFFFF，也可以用INT_MAX代替，但是一旦进行一些加减乘除容易溢出。如果改用0x3f3f3f3f，不会那么容易溢出，并且它的数量级已经达到了10^9，足以表示无穷大。
#include &lt;bits/stdc++.h&gt;

using namespace std;

int m1...]]></description><category></category></item><item><title><![CDATA[Codeforces Round #572 (Div. 1) A2. Add on a Tree: Revolution]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/96007180</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/96007180</guid><author>keylamy</author><pubDate>Tue, 16 Jul 2019 14:41:51 +0800</pubDate><description><![CDATA[A2. Add on a Tree: Revolution

能不能达到目标结构的条件就是上个subtask讨论过的，只要没有度为2的点就可以
接下来讨论每条边如何变成需要的值，对于一条路，假如两个端点它们都是非叶子节点，记作A，B，取A的不同子树（不包含B）上的两个叶子a1，a2，B的两个不同子树（不包含A）上的两个叶子b1，b2，那么若AB间的路要达到某个值val，a1到b1加val/2，a2...]]></description><category></category></item><item><title><![CDATA[GoLang入门D3]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/96098742</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/96098742</guid><author>keylamy</author><pubDate>Tue, 16 Jul 2019 10:58:13 +0800</pubDate><description><![CDATA[今天学习一些运算符和学习一些关键字的使用
运算符
&amp;   |    ^    &amp;^
这四个位运算符分别是按位与，按位或，按位异或，位清除
其中位清除是GoLang特有的
a&amp;^b使得a发生变化，a与b相同的位清零，a与b不同的位保留
a&amp;^b相当于a&amp;^=b，相当于a&amp;=~b
Go不支持运算符、方法重载，但是某些内建运算符支持重载，比如+可以连接in...]]></description><category></category></item><item><title><![CDATA[GoLang入门D2]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/95940826</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/95940826</guid><author>keylamy</author><pubDate>Mon, 15 Jul 2019 11:27:49 +0800</pubDate><description><![CDATA[今天学的是变量类型、声明、赋值等
值的类型

int/uint类型长度取决于本机架构，要么32要么64
当然可以直接声明int8 int16 int32 int64，uint8 uint16 uint32 uint64，byte
byte是uint8的别称，本质是一样的
没有float类型，没有double类型，只有float64和float32
无论是什么架构，int32长度就是32不会变，in...]]></description><category></category></item><item><title><![CDATA[Codeforces Round #572 (Div. 2) D1. Add on a Tree]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/95930160</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/95930160</guid><author>keylamy</author><pubDate>Sun, 14 Jul 2019 21:50:54 +0800</pubDate><description><![CDATA[D1. Add on a Tree
若要每种情况都能满足，也就是说，每条边的变化都要独立。假如有一种情况，无论选哪两个叶子节点，总有两条边它们是一起变化的，换句话说，永远相等，那这就不能满足条件。假如每条边的变化都独立的话，那么每条边总能通过适当的变化达到某个目标值。今天有听同学说到任意两边都需要有净增值，还用到了线性代数来解释，本质是一样的，只是这个说法蛮有意思的。
所以，先分析一下，总有两条边...]]></description><category></category></item><item><title><![CDATA[GoLang入门D1]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/95723437</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/95723437</guid><author>keylamy</author><pubDate>Sat, 13 Jul 2019 09:26:56 +0800</pubDate><description><![CDATA[Go语言特点

编译型语言，有着静态语言的高效性
语法简单，有着动态语言的易开发性，强制防止导入不使用的包
并发性，可以指定CPU使用核数
2009年发布正式版本
原生支持UTF-8

应用

油管的后台
七牛云

开发环境

go安装包
配置GOPATH
Sublime Text 3 + gosublime

调试

命令行输入go env查看基本配置
命令行输入go查看go命令
命令行godo...]]></description><category></category></item><item><title><![CDATA[洛谷 P1886 滑动窗口]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/95108332</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/95108332</guid><author>keylamy</author><pubDate>Mon, 08 Jul 2019 22:35:17 +0800</pubDate><description><![CDATA[洛谷 P1886 滑动窗口
单调队列：
单调递增队列：使得每个入队元素都小于已有元素
保持递增：遇到队尾元素小于未入队元素时，弹出队尾再使未入队元素入队
数据结构：deque，因为滑动窗口需要判断队列元素是否过时，而deque可以通过pop_front()弹出队首元素
每次滑动都记录队首元素即可。
#include &lt;bits/stdc++.h&gt;
using namespace std...]]></description><category></category></item><item><title><![CDATA[随便学（一）]]></title><link>https://blog.youkuaiyun.com/keylamy/article/details/90678981</link><guid>https://blog.youkuaiyun.com/keylamy/article/details/90678981</guid><author>keylamy</author><pubDate>Wed, 29 May 2019 21:32:10 +0800</pubDate><description><![CDATA[二分搜索

要求是排好序的数组中查找
注意当hi，lo较大的时候，因为hi+lo有可能溢出，所以不用(hi+lo)/2

递归
int rank1(int key,int a[],int lo,int hi){
    if(lo&gt;hi)
        return -1;
    int mid=lo+(hi-lo)/2;
    if(a[mid]&lt;key)
        re...]]></description><category></category></item></channel></rss>