hihoCoder-1039、字符消除|ACM-hiho-字符串

#1039 : 字符消除

描述

小Hi最近在玩一个字符消除游戏。给定一个只包含大写字母”ABC”的字符串s，消除过程是如下进行的：

1)如果s包含长度超过1的由相同字母组成的子串，那么这些子串会被同时消除，余下的子串拼成新的字符串。例如”ABCCBCCCAA”中”CC”,”CCC”和”AA”会被同时消除，余下”AB”和”B”拼成新的字符串”ABB”。
2)上述消除会反复一轮一轮进行，直到新的字符串不包含相邻的相同字符为止。例如”ABCCBCCCAA”经过一轮消除得到”ABB”，再经过一轮消除得到”A”

游戏中的每一关小Hi都会面对一个字符串s。在消除开始前小Hi有机会在s中任意位置(第一个字符之前、最后一个字符之后以及相邻两个字符之间)插入任意一个字符(‘A’,’B’或者’C’)，得到字符串t。t经过一系列消除后，小Hi的得分是消除掉的字符的总数。

请帮助小Hi计算要如何插入字符，才能获得最高得分。

输入

输入第一行是一个整数T(1<=T<=100)，代表测试数据的数量。

之后T行每行一个由’A’’B’’C’组成的字符串s，长度不超过100。

输出

对于每一行输入的字符串，输出小Hi最高能得到的分数。

提示

第一组数据：在”ABCBCCCAA”的第2个字符后插入’C’得到”ABCCBCCCAA”，消除后得到”A”，总共消除9个字符(包括插入的’C’)。

第二组数据：”AAA”插入’A’得到”AAAA”，消除后得到””，总共消除4个字符。

第三组数据：无论是插入字符后得到”AABC”,”ABBC”还是”ABCC”都最多消除2个字符

样例输入

3
ABCBCCCAA
AAA
ABC

样例输出

9
4
2

限制

时间限制:10000ms
单点时限:1000ms
内存限制:256MB

思路

  1. 在给定字符串中的任意位置插入’A’、’B’、’C’中的任意一个字符，然后计算插入后的字符经过消除后最短的字符串长度。
  2. 在计算字符消除后最短长度时，通过递归反复计算。
  3. 记录每次插入一个字符后经过第2步计算后最短的字符串长度min，最后原字符串的长度-min+1。

题解

C++

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
43
44
45
46
47
48
49
50
51
52
/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <bits/stdc++.h>

using namespace std;
const int INF=0x3f3f3f3f;

int cal(string p) {
    int len = p.size();
    if(p.empty())
        return 0;
    string t = "";
    int l = 0;
    p += "*";
    for(int i=1; p[i]; i++) {
        if(p[i] != p[i-1]) {
            if(l == i-1) {
                t += p[i-1];
            }
            l = i;
        }
    }
    if(t.size() == len)
        return 0;
    return len-t.size()+cal(t);
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int t;
    cin >> t;
    while(t--) {
        string s;
        string insert[3] = {"A","B","C"};
        cin >> s;
        int ans=0;
        for(int i=0; s[i]; i++) {
            for(int j=0; j<3; ++j) {
                string tmp = s;
                tmp.insert(i, insert[j]);
                ans = max(ans, cal(tmp));
            }
        }
        cout << ans << endl;
    }
    return 0;
}

Java

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
43
44
45
46
47
import java.util.Scanner;

public class Main {
    /*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        while(T-- > 0) {
            StringBuffer input = new StringBuffer(in.next());
            int ans = 0;
            int len = input.length();
            for(int i=0; i<len; ++i) {
                for(char ch='A'; ch<='C'; ++ch) {
                    StringBuffer tmp = new StringBuffer(input);
                    tmp = tmp.insert(i, ch);
                    ans = Math.max(ans, cal(tmp));
                }
            }
            System.out.println(ans);
        }
        in.close();
    }
    public static int cal(StringBuffer string) {
        int len = string.length();
        if(len<=0)
            return 0;
        StringBuffer buffer = new StringBuffer("");
        int l = 0;
        string.append("*");
        for(int i=1; i<len+1; ++i) {
            if(string.charAt(i) != string.charAt(i-1)) {
                if(l == i-1) {
                    buffer.append(string.charAt(i-1));
                }
                l = i;
            }
        }
        if (buffer.length() == len) {
            return 0;
        }
        return len-buffer.length()+cal(buffer);
    }
}
C++ STL总结|C++-ACM

C++ STL总结

String

length && size

size_t size() const noexcept;返回 string 长度。

string::length() 与 string::size() 完全相同。

substr

string substr (size_t pos = 0, size_t len = npos) const;产生子串
返回一个新建的初始化为 string 对象的子串的拷贝 string 对象。

子串是，在字符位置 pos 开始，跨越 len 个字符（或直到字符串的结尾，以先到者为准）对象的部分。

1
2
3
string str="We think in generalities, but we live in details.";
string str2 = str.substr (3,5);     // "think"
string str3 = str.substr (3);     // get from "think" to the end

string()

String(number, character)返回 string

1
2
3
4
5
6
7
8
9
z=string(3,"w")   //"www"
z=string(3,"aw")  //"awa"
z=string(3,"www") //"www"

vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
z = string(v.begin(), v.end()); //"abc"

empty

true if the string length is 0, false otherwise.

insert

返回插入的第一个字母的 iterator 以及修改过后的 str

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// inserting into a string
#include <iostream>
#include <string>

int main ()
{
  std::string str="to be question";
  std::string str2="the ";
  std::string str3="or not to be";
  std::string::iterator it;

  // used in the same order as described above:
  str.insert(6,str2);                 // to be (the )question
  str.insert(6,str3,3,4);             // to be (not )the question
  str.insert(10,"that is cool",8);    // to be not (that is )the question
  str.insert(10,"to be ");            // to be not (to be )that is the question
  str.insert(15,1,':');               // to be not to be(:) that is the question
  it = str.insert(str.begin()+5,','); // to be(,) not to be: that is the question
  str.insert (str.end(),3,'.');       // to be, not to be: that is the question(...)
  str.insert (it+2,str3.begin(),str3.begin()+3); // (or )

  std::cout << str << '\n';
  return 0;
}
hihoCoder-1000、A + B|ACM-hiho

#1000 : A + B

描述

求两个整数A+B的和

输入

输入包含多组数据。

每组数据包含两个整数A(1 ≤ A ≤ 100)和B(1 ≤ B ≤ 100)。

输出

对于每组数据输出A+B的和。

样例输入

1 2
3 4

样例输出

3
7

限制

时间限制:10000ms
单点时限:1000ms
内存限制:256MB

思路

经典题

题解

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <bits/stdc++.h>

using namespace std;
const int INF = 0x3f3f3f3f;

int main() {
    int a, b;
    while(cin >> a >> b) {
        cout << a+b << endl;
    }
    return 0;
}

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Scanner;

public class Main {
    /*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(a+b);
        }
        in.close();
    }
}
hihoCoder-1326、有序01字符串|ACM-hiho-字符串

#1326 : 有序01字符串

描述

对于一个01字符串，你每次可以将一个0修改成1，或者将一个1修改成0。那么，你最少需要修改多少次才能把一个01串 S 变为有序01字符串(有序01字符串是指满足所有0在所有1之前的01串)呢？

输入

第一行是一个整数 T，代表测试数据的组数。(1 ≤ T ≤ 10)

以下T行每行包含一个01串 S 。(1 ≤ |S| ≤ 1000)

输出

对于每组测试数据输出最少需要修改的次数。

样例输入

3
000111
010001
100000

样例输出

0
1
1

限制

时间限制:10000ms
单点时限:1000ms
内存限制:256MB

思路

最终总会按照某位分段，前面位0，后面为1。那么改动的次数，就是分段的那位前面的1的个数和后面的0的个数的和。统计每一位前面的1的个数个后面的0的个数，找出和的最小值，就可以了。不需要考虑这一位本身是1还是0，因为不管是0还是1都不需要改变。 比如：

字符串 ： 0 0 1 0 1 0 0 1 0 1 1 1 0 1
前面的1的个数： 0 0 0 1 1 2 2 2 3 3 4 5 6 6
后面的0的个数: 6 5 5 4 4 3 2 2 1 1 1 1 0 0
个数和 ： 6 5 5 5 5 5 4 4 4 4 5 6 6 6

题解

C++

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
/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <bits/stdc++.h>

using namespace std;
const int INF = 0x3f3f3f3f;

int main() {
    int T;
    cin >> T;
    while(T--) {
        string s;
        cin >> s;
        int len = s.length();
        int ans = INF;
        int cnt0, cnt1;
        for(int i=0; i<=len; ++i) {
            cnt0 = cnt1 = 0;
            for(int j=i-1; j>=0; --j)
                cnt0 += s[j]=='0' ? 0:1;
            for(int j=i; s[j]; ++j)
                cnt1 += s[j]=='1' ? 0:1;
            ans = min(ans, cnt0+cnt1);
        }
        cout << ans << endl;
    }
    return 0;
}

Java

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
import java.util.Scanner;

/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        while(T-- > 0) {
            char[] list = in.next().toCharArray();
            int l = list.length;
            int cnt0, cnt1;
            int ans = 0x3f3f3f3f;
            for(int i=0; i<=l; ++i) {
                cnt0 = cnt1 = 0;
                for(int j=i-1; j>=0; --j) {
                    if(list[j] == '0')
                        cnt0 += 0;
                    else cnt0 += 1;
                }
                for(int j=i; j<l; ++j) {
                    if(list[j] == '1')
                        cnt1 += 0;
                    else cnt1 += 1;
                }
                if(ans > cnt0+cnt1)
                    ans = cnt0+cnt1;
            }
            System.out.println(ans);
        }
        in.close();
    }
}
为何程序员喜欢将 INF 设置为 0x3f3f3f3f ？(转)|C++

在算法竞赛中，我们常常需要用到一个“无穷大”的值，对于我来说，大多数时间我会根据具体问题取一个99999999之类的数（显得很不专业啊！）

在网上看别人代码的时候，经常会看到他们把INF设为 0x7fffffff ，奇怪为什么设一个这么奇怪的十六进制数，一查才知道，因为这是 32-bit int 的最大值。如果这个无穷大只用于一般的比较（比如求最小值时 min 变量的初值），那么 0x7fffffff 确实是一个完美的选择。

但是更多情况下， 0x7fffffff 并不是一个好的选择，比如在最短路径算法中，我们使用松弛操作：

1
2
if(d[u]+w[u][v]<d[v])
    d[v]=d[u]+w[u][v];

如果 u,v 之间没有边，那么 w[u][v]=INF ，如果我们的 INF 取 0x7fffffff ，那么 d[u]+w[u][v] 会溢出而变成负数，我们的松弛操作便出错了！

准确来说， 0x7fffffff 不能满足“无穷大加一个有穷的数依然是无穷大”这个条件，它会变成了一个很小的负数。

更进一步的，如果有一个数能够满足“无穷大加无穷大依然是无穷大”，那么就更好了！

前阵子无意中看到了一个不一样的取值， INF=0x3f3f3f3f ，这时我又郁闷了，这个值又代表的是什么？于是我去寻找答案，发现这个值的设置真的很精妙！

0x3f3f3f3f的十进制是1061109567，是10^9级别的（和0x7fffffff一个数量级），而一般场合下的数据都是小于10^9的，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形。

另一方面，由于一般的数据都不会大于10^9，所以当我们把无穷大加上一个数据时，它并不会溢出（这就满足了“无穷大加一个有穷的数依然是无穷大”），事实上 0x3f3f3f3f+0x3f3f3f3f=2122219134 ，这非常大但却没有超过32-bit int 的表示范围，所以 0x3f3f3f3f 还满足了我们“无穷大加无穷大还是无穷大”的需求。

最后，0x3f3f3f3f还能给我们带来一个意想不到的额外好处：
如果我们想要将某个数组清零，我们通常会使用memset(a,0,sizeof(a))，方便又高效，但是当我们想将某个数组全部赋值为无穷大时，就不能使用memset函数而得自己写循环了，因为memset是按字节操作的，它能够对数组清零是因为0的每个字节都是0（一般我们只有赋值为-1和0的时候才使用它）。现在好了，如果我们将无穷大设为0x3f3f3f3f，那么奇迹就发生了，0x3f3f3f3f的每个字节都是0x3f！所以要把一段内存全部置为无穷大，我们只需要memset(a,0x3f,sizeof(a))。

所以在通常的场合下，0x3f3f3f3f真的是一个非常棒的选择！

参考资料

【算法设计与数据结构】为何程序员喜欢将INF设置为0x3f3f3f3f？

ACM 竞赛小技巧|C++-ACM

ACM 竞赛小技巧

for循环

当使用 for 循环从头至尾去循环一个数组 s 的时候，可以用

1
for(int i=0; s[i]; ++i)

INF

1
const int INF = 0x3f3f3f3f;

具体原因参见为何程序员喜欢将 INF 设置为 0x3f3f3f3f ？

long long

在计算过程中可以用

1
long long ans = 1LL * x * x;

将原先被设置成 int 类型的整数转化成 long long 类型。

Windows 下利用 Cygwin 搭建 C/C++ 开发环境|Clion-开发环境

暑假学校进行实验室保密检查，把实验室的电脑全部装上了一个影子卫士之类的软件，却莫名其妙的把我的编译环境全部弄坏了，因此选择重装。我的 C 语言 IDE 是 JetBrains 家的 Clion。 Clion 对 MinGW 的支持不是很好，会出现输入回显等奇怪的现象，因此选择 Cygwin。

原本网上Cygwin的安装配置教程很多的，也就没想着存档，然而今天想找出来时却发现一夜之间所有教程都不见了，于是便将我好不容易在新浪博客上找到的教程扒出来贴在自己的博客里。

下载Cygwin

首先去网站 Cygwin官网 下载 Cygwin 的 Windows系统的安装包，32位系统下载steup-x86.exe，64位系统则下载steup-x86_64.exe，界面如下。

安装

  1. 双击下载好的Cygwin安装包，出现安装界面，点击下一步。之后出现如下界面，默认为第一个选项，意思是从网络下载并安装（从官网下载的不是完整安装包，只是安装引导程序），第二个选项是仅仅下载不安装，第三个则是从本地安装（意思是已经下载好了需要的安装文件）。我还没有下载好文件，并且要安装，所以选择默认第一项，之后点击下一步。

  2. 在这里选择安装目录，一般要有一个专门用来作开发工具的安装目录，我这里在为C:\Develop，并在此文件下新建用来安装Cygwin的目录，所以总的目录为C:\Develop\MinGW。选择所有用户，之后点击下一步。

  3. 这里要为将要下载的安装包选择存放位置，我选择在C盘的下载目录。选择好后点击下一步。

  4. 选择默认，点击下一步。

  5. 闪过一个页面之后出现如下界面，选择蓝色的网址，这是国内中科大的镜像站，所以网速较快，东北地区的也可以选择上面那一个，是大连东软学院的镜像站，隔得较近，应该比中科大的快。

  6. 在这个页面之后，就是最重要的一个地方了，会自动进入下一步。

  7. 在画红线处分别搜索 gcc-core、gcc-g++、make、gdb、binutils，以上所有项目都在 devel 文件夹下。

  8. 原本的 5.3.0-5 (版本号变大了是正常的事情，反正是数字就对了)位置也是 Skip，在点击一次之后，出现如下界面即可，其他的也一样。 gcc-core
    gcc-g++
    make
    gdb
    binutils

  9. 之后点击左下角的下一步。

  10. 这里检查要安装的项目，和上面选择的是不一样的，增加了许多相关的文件，不好检查，不过一般没问题，所以直接点击下一步。

  11. 此时开始下载并安装Cygwin，时间稍微久一点。

  12. 根据需要是否在桌面（第一项）和开始菜单（第二项）创建快捷方式，因为我不常用终端模式，但有时候可能需要，所以只选择第二项，点击完成。

  13. 将安装目录下的 bin目录 添加到 Path 环境变量。

验证安装

验证是否安装成功。打开命令提示符窗口，输入 gcc -v，出现以下情况说明安装成功。

参考文献

Windows下利用Cygwin搭建C/C++开发环境GCC

Hexo 博客多机更新|Hexo

晚上回寝室，想用电脑写博客时发现自己平常随身携带的本子忘记带回寝室了，于是便上网搜索了一下如何使用不同的电脑更新同一个博客，感谢CrazyMilk在知乎上提供的方法。

这里假设你已经创建出了自己的博客并希望可以将其修改为适合多机使用的情况，如果没有创建出自己的博客，请参照我的这一篇博客：使用hexo+github搭建我的个人博客

一、 创建分支

对你的博客的仓库创建一个新的分支。

右击左上角的 Branch ，在弹出的界面的输入框里输入 HEXO 并回车。

创建完成之后如下图所示

二、 设置 HEXO 为默认分支

在页面的最上方寻找到Settings选项

在左侧选择 Branches 将其中的 Default branch 更改为 HEXO

回到本仓库的首页，选择 upload 将博客的源文件全部上传至此远程仓库。此时的分支应为 HEXO

三、 下载博客源文件

在自己选定的地方打开 git bash 使用

1
git clone git@github.com:Yuki-14544869/Yuki-14544869.github.io.git //将这里的Yuki-14544869改成你的用户名

拷贝仓库

四、 搭建环境

在下载下来的文件夹下打开 git bash 依次执行,此时当前分支应显示为 HEXO

1
2
3
4
npm install hexo-cli -g
npm install hexo --save   //先安装 hexo
npm install
npm install hexo-deployer-git

五、 修改配置

修改站点配置文件 _deploy 参数，分支应为master

六、 上传博客源文件

与 git 提交代码的方式无二，依次执行

1
2
3
git add .
git commit -m "..."
git push origin HEXO

指令将文件推送至 GitHub 此时当前分支应显示为 HEXO

–

七、 更新博客

执行

1
hexo g -d

将博客发布

这样一来，在GitHub上的https://github.com/Yuki-14544869/Yuki-14544869.github.io仓库就有两个分支，一个hexo分支用来存放网站的原始文件，一个master分支用来存放生成的静态网页。完美( •̀ ω •́ )y！

参考资料

  1. 使用hexo，如果换了电脑怎么更新博客？
hihoCoder-1324、希尔伯特曲线|ACM-hiho-几何-分治

#1324 : 希尔伯特曲线

描述

希尔伯特曲线是以下一系列分形曲线 Hn 的极限。我们可以把 Hn 看作一条覆盖 2n × 2n 方格矩阵的曲线，曲线上一共有 2n × 2n 个顶点(包括左下角起点和右下角终点)，恰好覆盖每个方格一次。

Hn(n > 1)可以通过如下方法构造：

  1. 将 Hn-1 顺时针旋转90度放在左下角

  2. 将 Hn-1 逆时针旋转90度放在右下角

  3. 将2个 Hn-1 分别放在左上角和右上角

  4. 用3条单位线段把4部分连接起来

对于 Hn 上每一个顶点 p ，我们定义 p 的坐标是它覆盖的小方格在矩阵中的坐标，定义 p 的序号是它在曲线上从起点开始数第几个顶点。给定 p 的坐标，你能算出 p 的序号吗？

输入

输入包含3个整数 n , x , y 。 n 是分形曲线的阶数，(x, y)是 p 的坐标。

1 ≤ n ≤ 30

1 ≤ x, y ≤ 2n

输出

p 的序号。

样例输入

3 6 1

样例输出

60

限制

时间限制:10000ms
单点时限:1000ms
内存限制:256MB

思路

题目中已经说明Hn是由4个Hn-1旋转拼接而成，递归的结构非常明显。所以对于求Hn中(x, y)的序号，我们自然而然会想能否转化成在Hn-1中求(x’, y’)的序号。

实际上我们只需要考虑Hn中的(x, y)是在左下、左上、右上、右下4个Hn-1中的哪一个里，即可转化成在Hn-1中求(x’, y’)序号的子问题。具体(x, y)到(x’, y’)的对应关系涉及到坐标平移和旋转，留给大家思考，不再赘述。

以样例为例，如上图所示，H3中的(6, 1)在右下角的H2中，并且对应着H2中(4, 3)这个点。

如果我们能正确求出H2中(4, 3)这个点的序号是12，又因为前3个H2中一共包含16x3=48个点，那么我们就能求出H3中的(6, 1)的序号是12+48=60。

最后需要注意的是n=30时一共包含2^60个点，所以计算序号的时候需要用64位整型存储。

坐标变换


如图，
当判断点实在当前图形的1位置时，需要将图像对于直线 x=y 进行翻折，即交换x，y的值。
当判断点实在当前图形的2位置时，只需将图像向下平移即可，即 x 不变，y-m。
当判断点实在当前图形的3位置时，同样是将图像平移至1位置即可，即 x-m, y-m。
当判断点实在当前图形的4位置时，先需要将图像平移至1位置,再将图像对于直线 x=-y 进行翻折，即 x=m+1-y, y=2*m+1-x。

题解

C++

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
/*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
*/
#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int INF = 0x3f3f3f3f;
LL HilbertNumber(int n, int x, int y) {
    if(n==0)
        return 1;
    int m = 1<<(n-1);

    if(x<=m) {
        if(y<=m)
            return HilbertNumber(n-1, y, x);
        else
            return 1LL*m*m + HilbertNumber(n-1, x, y-m);
    } else {
        if(y>m)
            return 2LL*m*m + HilbertNumber(n-1, x-m, y-m);
        else
            return 3LL*m*m + HilbertNumber(n-1, m+1-y, 2*m+1-x);
    }
}
int main() {
    int n, x, y;
    cin >> n >> x >> y;
    cout << HilbertNumber(n, x, y) << endl;
    return 0;
}

Java

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
import java.util.Scanner;

public class Main {
    /*
    Author: Yuki
    GitHub: https://github.com/Yuki-14544869/
    Blog:   https://yuki-14544869.github.io/
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();

        System.out.println(HilbertNumber(n, x, y));
        in.close();
    }
    public static long HilbertNumber(int n, int x, int y) {
        if(n==0)
            return 1;
        int m = 1<<(n-1);

        if(x<=m) {
            if(y<=m)
                return HilbertNumber(n-1, y, x);
            else
                return 1L*m*m + HilbertNumber(n-1, x, y-m);
        } else {
            if(y>m)
                return 2L*m*m + HilbertNumber(n-1, x-m, y-m);
            else
                return 3L*m*m + HilbertNumber(n-1, m+1-y, 2*m+1-x);
        }
    }
}
提取 Windows 10 锁屏壁纸|Windows

Windows 10 有一个叫做 「Windows 聚焦」的功能，会定期精选一些壁纸作为锁屏壁纸。可惜它并没有提供下载功能，当你看到一些很漂亮的照片，如何将它保存下来，用作其它壁纸呢？

按 Win + R，复制引号内的代码输入即可进入锁屏壁纸的存放文件夹。 “%localappdata%\Packages\Microsoft.Windows.ContentDeliveryManager_cw5n1h2txyewy\LocalState\Assets”

然后将里面的文件复制到其他文件夹中，后缀改成「.jpg」即可正常显示。（请勿在原文件夹中修改。）

如果你不想手动修改，也可以使用批量修改。在文件夹里新建一个文本文档，打开在里面输入

1
ren * *.jpg  //每个星号前面都有空格

保存，然后将新建文档后缀名「txt」改成「bat」，双击运行。

同一张图片会有竖屏和横屏两种模式，可以方便地为设置为手机壁纸。需要注意的是，这些文件夹里面也会掺杂一些其它缓存的图片。

参考文献

有办法提取 Win 10 的锁屏壁纸吗？| 有轻功 #155

微信扫一扫关注 AppSo 公众号