以前写的弱智玩意

以前写的弱智玩意（算笔记吧）收拾电脑找到的 是不是应该私密下233

2017_3_15

！优先级高于%*/,与+-（代表符号而不是加减运算）同级
实例：if(n%100&&!(n%4)||!(n%400))
if(n%100&&!n%4||!n%400)
1对2错
如果不加括号程序会对n取反即0为1，非0为0，然后进行取余运算，结果自然出错。


三角函数返回值是 double


Pi值尽量多写几位，不然可能出错
#define Pi 3.14159265358979


abs函数返回值是int！int!int!
重要的事情说三遍
fabs()能用。话说不就是把1变成0嘛，弄这么麻烦干啥。


2017_3_16
pow函数返回值是double，
计算指数时
不能写成 printf("%d",pow(2,2);
而要写成 printf("%.f",pow(2,2);
备注：要算以2为底的指数时，可以写成1 << n 既是结果，可以用int


int 可以用%c存数据，不过是字符（ASC）方式存的




2017_3_17
计算机杂谈：
风语 2017/3/17 19:47:55
显哥在不
有个问题想问你
#include
#include
char a[10];
int main(){
    memset(a,0,sizeof(a));
    int i = 0;
    while(!a[i]){
        printf("%d ",i);
        i++;
    }
    return 0;
}
#include
#include
int main(){
    char a[10];
    memset(a,0,sizeof(a));
    int i = 0;
    while(!a[i]){
        printf("%d ",i);
        i++;
    }
    return 0;
}


风语 2017/3/17 19:49:22
为什么第一个会一直输出到31而第二个输出到9呢


大佬 2017/3/17 20:40:11
我看看下，刚上课回来


大佬 2017/3/17 20:43:00
...你这两个代码有区别么,,,


风语 2017/3/17 20:43:06
有
第一个输出一直到31
第二个一直输出到9


大佬 2017/3/17 20:44:27
哦哦,两个char数组位置不一样


风语 2017/3/17 20:44:33
对
第一个在主函数外面


大佬 2017/3/17 20:47:17
你第一个开个 33 看一下
告诉我输出多少


风语 2017/3/17 20:47:37
83


大佬 2017/3/17 20:49:00
感觉和堆栈有关


大佬 2017/3/17 20:50:03
我们的计算机的硬盘(也就是存储空间)是由无数的最小单位的存储器组成,
你记不记得,宇哥第一次讲课的时候说过,开特别大的数组要开在函数外


风语 2017/3/17 20:51:07
嗯嗯 在函数外面是堆存储


大佬 2017/3/17 20:51:32
否则会爆栈-->说明，这时候程序代码和数据是存在初期开的一块栈里


大佬 2017/3/17 20:53:26
我们的c，c++属于静态语言，也就是必须在声明定义的时候，必须预编译告诉计算机你需要多大内存，然后试着开一下，开不出来，即爆栈，return error
然而你在程序外面开的话，是新开辟的一块空间
大佬 2017/3/17 20:55:14
这和硬件有关，我们的寄存器在X64情况下，最小是开一个int，也就是4char
一个字节，8个bit，由于没有使用，so，是干净的，即使memset函数，我觉得也是可以输出到31的
即使没有使用memset函数


风语 2017/3/17 20:57:29
嗯嗯 memset 删了也是31


大佬 2017/3/17 20:57:46
你可以试试，先将这十个元素置为a，输出 a[i]=='a',看看，是不是输出到10


大佬 2017/3/17 20:59:34
说错了，应该是9...


风语 2017/3/17 20:59:46
哈哈哈
没错


风语 2017/3/17 20:59:52
是9


大佬 2017/3/17 21:00:19
so,我说明白了么...


一句话总结：数组越界……




2017_3_18
#include
作用：limits.h专门用于检测整型数据数据类型的表达值范围。
例：
INT_MAX
INT_MIN


结构体定义
http://blog.csdn.net/xiaoyali/article/details/4393486
结构体排序
http://blog.csdn.net/martinue/article/details/51758888


struct data{
    int x;
    int y;
} a[3];
bool cmp1(data m,data n){//x升序
    return m.x }
bool cmp2(data m,data n){//y降序
    return m.y > n.y;
}
bool cmp3(data m,data n){//先x升序，若x相等，则按y升序
    if(m.x==n.x)
        return m.y    return m.x}
sort(a,a+3,cmp);




2017_3_19
关于sort()函数
http://blog.csdn.net/ajioy/article/details/6976945
https://zhidao.baidu.com/question/216527176.html




2017_3_20
随堂笔记：关于算法优化的一点启示：
例如水仙花数：一个三位数abc=a*a*a+b*b*b+c*c*c既是水仙花数。
不难想到的算法是将一个整数通过取整取余等等等转化为三个整数，然后做立方和。固然，这种方式是可以的，因为只有三位，怎样算都不会超时。可如果是11位以上，甚至超过long long的最大值呢？
这时，便可以用gets（或scanf）读入一个字符串，直接将字符串各字符立方（减48），这样，就解决了整数最大值的限制问题。
但是，又一个问题出现了：不管是a*a*a，还是pow（a，3）,都会耽误大量的时间。这是，完全可以用switch，将每一种情况并列出来，这样，每一次运算的复杂度就只是o(n),
在上亿之前，应该是都可以跑出来的。（百度了一发后，发现pow函数的实现方式并不简单，是用泰勒展开算出来的，要是只考虑3次方的话，t（pow）>t（a*a*a）>t（pow））；
pow函数要慎用！认真脸 0.0
sin啦 cos啦 好像都是用泰勒公式写的，嗯嗯。




2017_3_25
这几天都为cccc准备，脑子乱乱的，没写啥
getchar();很重要！！！（认真脸）
比赛时后遇到一个题，虽然过了，但是做法很麻烦。其实就是基于字符串和数字的相互转换。
http://www.cnblogs.com/bluestorm/p/3168719.html
http://blog.sina.com.cn/s/blog_4c8a2a870100qgq7.html
1.int/float to string/array:
C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串，下面列举了各函数的方法及其说明。
● itoa()：将整型值转换为字符串。itoa(int *,char *,10)10表示进制
● ltoa()：将长整型值转换为字符串。
● ultoa()：将无符号长整型值转换为字符串。
● gcvt()：将浮点型数转换为字符串，取四舍五入。
● ecvt()：将双精度浮点型值转换为字符串，转换结果中不包含十进制小数点。
● fcvt()：指定位数为转换精度，其余同ecvt()。
除此外，还可以使用sprintf系列函数把数字转换成字符串，其比itoa()系列函数运行速度慢
2. string/array to int/float
C/C++语言提供了几个标准库函数，可以将字符串转换为任意类型(整型、长整型、浮点型等)。
● atof()：将字符串转换为双精度浮点型值。
● atoi()：将字符串转换为整型值。
● atol()：将字符串转换为长整型值。
● strtod()：将字符串转换为双精度浮点型值，并报告不能被转换的所有剩余数字。
● strtol()：将字符串转换为长整值，并报告不能被转换的所有剩余数字。
● strtoul()：将字符串转换为无符号长整型值，并报告不能被转换的所有剩余数字。
感觉有好多……慢慢研究吧








2017_3_26
strcmp(字符串比较函数):
http://c.biancheng.net/cpp/html/162.html
strcoll
http://c.biancheng.net/cpp/html/163.html
从第一个字符向下扫逐个比较
strcmp(a,b);
a==b return 0
a>b  return>0
a不一定是1 0 -1








2017_3_27
strcpy函数:
strcpy(a,b);
把字符串b的值赋给a；
#include
#include
int main(){
    char a[2];
    char b[10] = "12345678";
    strcpy(a, b);
    printf("%d", a[2]);
    return 0;
}
//注意：输出结果为3；输出结果是正确的，但是这种方式不可取，因为它将会改变后面的内存中的值。






2017_3_31
#include
#include
#include
using namespace std;
int main(){
    stack a;
    queue b;
    a.push(1);
    b.push(1);//压入数据
    
    a.size();
    b.size();//长度
    
    b.front();//队列头
    b.back();//队列尾
    
    a.top();//栈顶
    
    a.pop();//移除栈顶元素
    b.pop();//移除队列头
    
    a.empty();
    b.empty();//判断是否为空，空1非空0


    return 0;
}
当栈或队列为空时，使用front，back，top,pop会导致程序崩溃
妈个鸡，链表居然还有头文件：#include
可网上也说了，头文件里的链表没有自己写的效率高。。。
那也就是说，栈和队列应该也可以自己实现。。。

妈个鸡。。。

2017年4月2日21:12:51
存二进制可以bool存


2017年4月4日14:58:01
int 不能用%lld输出




2017年4月7日20:11:09
多边形面积（包含凹多边形）：
思路：将n边形分成n-1个三角形，每个顶点坐标既是从o点到该点的向量，之后利用叉乘算三角形面积。看图。








2017年4月8日19:23:58
补了一个题（大傻和小伙伴，cf上的），a了之后看别人代码的时候发现了一个很巧妙的环形数组；a[i%n],n是数组长度






2017年4月9日11:26:30
cin cout：
http://blog.csdn.net/zhanghaotian2011/article/details/8868577
http://blog.csdn.net/maweiqi/article/details/7950366
还挺好玩的 就是用不惯






2017年4月10日22:28:39
算逆序对数：
归并
4 3 2 1
分开后：
4 3    2 1
子序列排序：
3 4    1 2   这时会产生逆序对； 此时ans = 2；
对3 4 1 2排序：
1 < 3 ans += 2；加的是提前的距离。
2 < 4 ans += 2；
ans = 6；






Atcoder Beginner Contest 058题解：
if（着急）
goto pp;
比赛时候没做出来。。。不开心。。。
比赛的时候，一开始受样例的影响，以为可以用m,n找出和总面积之间的关系，例如2*2的方格，只需要把面积算四次，就是所要求的答案。但是想到了一种反例：例如，在一个3*2的方格中，位于两侧的方格算面积的次数会比中间的少算一次，这样形成的就不是完整的面积了。这个思路走不通。。。然后。。。有题解，嗯。。。题解看不懂。。。求和什么鬼。。。但是题解提醒了我可以用o(n+m)的复杂度算出来，经过一番冥思苦想之后


pp:
思路：不必求出所有矩形面积之后加和，只要求出每个矩形算面积长/宽的次数
求法：
看图；
另外，这个数最后的结果还要对一个数取余，同样的思路，每一次循环加一个取余就可以了。
看例子：
#include
using namespace std;


int main(){


    int a = 155 % 15;
    int b = 167 % 15;
    int c = (a + b) % 15;


    cout << a << endl;
    cout << b << endl;
    cout << c << endl;


    return 0;
}


输出结果是：
5
2
7
这玩意有个名字 叫同余模定理：
http://blog.csdn.net/qq_29600137/article/details/50821993
公式：
(a+b)%c=(a%c+b%c)%c;
(a*b)%c=(a%c*b%c)%c;








2017年4月12日18:32:55
cf 450 B
题意就是让你用循环实现一个类似斐波那契的过程，没啥难度，找规律的题，比hdu1005简单。只有一个地方：对负数取余。比如说，题目的要求是-1%3==2，但c语言实现的输出结果是-1%3==-1。又回去补了一发基础知识。


博弈论：
(Bouton's Theorem)：对于一个Nim游戏的局面(a1,a2,...,an)，它是P-position当且仅当a1^a2^...^an=0，其中^表示异或(xor)运算。
怎么样，是不是很神奇？我看到它的时候也觉得很神奇，完全没有道理的和异或运算扯上了关系。但这个定理的证明却也不复杂，基本上就是按照两种position的证明来的。


根据定义，证明一种判断position的性质的方法的正确性，只需证明三个命题： 1、这个判断将所有terminal position判为P-position；2、根据这个判断被判为N-position的局面一定可以移动到某个P-position；3、根据这个判断被判为P-position的局面无法移动到某个P-position。


第一个命题显然，terminal position只有一个，就是全0，异或仍然是0。


第二个命题，对于某个局面(a1,a2,...,an)，若a1^a2^...^an!=0，一定存在某个合法的移动，将ai改变成ai'后满足a1^a2^...^ai'^...^an=0。不妨设a1^a2^...^an=k，则一定存在某个ai，它的二进制表示在k的最高位上是1（否则k的最高位那个1是怎么得到的）。这时ai^k

第三个命题，对于某个局面(a1,a2,...,an)，若a1^a2^...^an=0，一定不存在某个合法的移动，将ai改变成ai'后满足a1^a2^...^ai'^...^an=0。因为异或运算满足消去率，由a1^a2^...^an=a1^a2^...^ai'^...^an可以得到ai=ai'。所以将ai改变成ai'不是一个合法的移动。证毕。


根据这个定理，我们可以在O(n)的时间内判断一个Nim的局面的性质，且如果它是N-position，也可以在O(n)的时间内找到所有的必胜策略。Nim问题就这样基本上完美的解决了。


。。。。。看不懂




vector:比赛的时候看到的，作用就是可以在后面顺次定义新变量；






2017年4月13日16:02:16
int最大值 ：0x7fffffff
int最小值 ：0x80000000
对递归的一点浅显的理解：
http://blog.csdn.net/qiujunchao/article/details/4373321
还有形参和实参的概念（基础很重要！）
http://blog.csdn.net/qq_33187168/article/details/50346465
or
c primer plus P107
但是我还是觉得刘汝佳讲的明白（P65）。


int f(int n){
return n==1 || n==2  ? 1 : f(n-1) + (n-2);
}
斐波那契，没啥说的。想说的是它内存复杂度时间复杂度方面的一些有关问题。
书上说n所占的内存会随程序的结束而释放。但，在运行的时候占用的内存还是要算出来的。
上代码：
#include
int t = 1;
int f(int a){
    printf("%d\n",t++);
    return a==1||a==2?1:f(a-1)+f(a-2);
}
int main(){
    int i=10;
    int c = f(i);
    printf("\n%d\n",c);
    return 0;
}
输出的是1~109和55，也就是说函数被调用了109次。怎么来的？10要调9,8；9要调8,7,8要调7,6……就是这样的过程：
输入的数 f()调用次数
1        1
2  1
3  3
4  5
5  9
6 15
...
也是一个递归的过程：
return a==1||a==2?1:f(a-1)+f(a-2)+1;
可以算出来，10的时候就是109；
知道了次数，别的也就好算了：
次数是109，时间复杂度就是o(109),空间复杂度也就是o(109*int);
对不对呢？开任务管理器，发现这个程序占得内存是400k
……根据某个巨巨说是爆栈的问题。。。恩。。。




2017年4月14日18:40:43
dfs初步：八皇后问题  hdu2553
代码：


#include
#include
int ans;
int map[20];
int n;
int jud;


void dfs(int cur){
    if(cur == n){
        ans++;
        return;
    }
    for(int i = 0; i < n; i++){
        jud = 1; map[cur] = i;
        for(int j = 0; j < cur; j++){
            if(map[cur]==map[j]||cur-j==map[cur]-map[j]||cur-j==map[j]-map[cur]){
                jud = 0;
                break;
            }
        }
        if(jud) dfs(cur+1);
    }
}


int main(){
    int a[10];
    for(int i = 1; i <= 10; i++){
        memset(map,0,sizeof(map));
        ans = 0;
        n = i;
        dfs(0);
        a[i-1] = ans;
    }
    while(scanf("%d",&n),n) printf("%d\n",a[n-1]);
    return 0;
}




思路：因为每一列都只会有一个皇后，索性开一个大小为n的数组，第i行第j个位置就是map[i]=j;cur就是当前所在的行数；第一个if的意思是判断cur有没有到n,第一个for是将map[cur]赋值，即在第cur行i列放一个棋子。第二层for循环判断的是是否有相同列和主副对角线；
比如说：   * 1 * 3 * * * *
这样的情况就会在第2组中被舍去。
只有上一行满足条件之后才会进入下一次的递归。






2017年4月17日15:12:55
poj 1321
思路：就是一个八皇后问题。
int jud(int y){
    for(int i = 0; i < n; i++)
        if(map[i][y]=='Q') return 0;
    return 1;
}
void dfs(int cur){
    if(k == 0){
        ans++;
        return;
    }
    if(cur==n)
        return;
    for(int i = 0; i < n; i++){
        if(jud(i)&&map[cur][i]=='#'){
            map[cur][i]='Q';
            k--;
            dfs(cur+1);
            map[cur][i]='#';
            k++;
        }
    }
    dfs(cur+1);
}
cur就是行数，剩下的都是已知。这个算法的优点是占的内存少。
优化的话就用一个数组来记录这一列有没有放棋子，加了一个n的数组，但是时间上能快上好多。




找到一个好玩的网站 http://hzwer.com/


2017年4月18日18:03:08
poj 1426
不用搜索 直接打表，题目水直接long long就能过 超了就用同余模
    a[0] = 1;
    for(int i=0,j=1;j<600000;i++){
        a[j] = a[i]*10;
        j++;
        a[j] = a[i]*10+1;
        j++;
    }
    //printf("%lld",a[599999]);
    for(int i = 1; i <=200; i++){
        for(int j = 0; j < 600000; j++){
            if(!(a[j]%i)){
                b[i] = a[j];
                break;
            }
        }
    }


一个巨巨的博客
http://blog.csdn.net/v_july_v




2017年4月21日20:52:51
kmp看好几天了，还是看不懂。。。
百无聊赖，随便找了几个水题做做
遇到了一道以前做过的题：hdu1097
就是求a^b的末位数字。巨水，打表题。但是当时我做的特别艰辛：是用switch做的，贼麻烦。不得不说看到了自己的成长，但是这个成长的过程有一点长了。还是要加快速度啊。。。






2017年4月22日21:54:14
今天的比赛真酸爽！哈哈哈哈！
有一个题目特别有意思：问你16进制数有几个洞？
洞？洞！
题解：
8 2
A 1
9 1
5 0
自己体会（手动滑稽）
题不重要，思想很重要：谁告诉你8就是代表伸八个手指头了！！兴许人家就是一二维图形呢！这引发了我一个更有意思的思考：8这个符号究竟代表着什么？是不是给它不同的数学定义，它就会变成另外一种截然不同的意义呢?再想远一点，其他的数字啦，其他的符号啦，不过只是一个方便记录的符号，完全可以有另外的意思。看到8就想到数字定义下的8，这算不算是一种惯性思维呢？在以后我们看到一些熟悉的数字啊，字母啊，公式定理啊，是不是应该看一看它是在哪一种方式下产生的符号呢？
这又令我想到另一个问题 : 1+1=? 不是哥德巴赫猜想那个，而是纯粹的 1+1会等于几呢？它依据的数学模型是什么？1代表的又是什么呢？
脑洞有多大，世界就有多大！




2017年4月25日18:53:03
位运算整理：下面的数都是针对二进制的数
按位取反：~
就是把一个二进制数各位都取反;
比方说 定义一个 unsigned int i = 0；
~i 输出的就是 4294967295 即 0x ffff ffff；
另外，~-1==0，所以while(~scanf())和while(scanf()!=EOF)是相同的
按位与：&
字面意思，一位一位比较，都是1就是1，不然就是0；
例如，a&1就可以判断a是不是奇数啦，是不是很厉害
按位或：|
字面意思，一位一位比较，一个是1就行
按位异或：^
字面意思，一位一位比较，一样是0，不一样是1；
在博弈论里有黑科技哟！
左移：<< 
把整个数左移1位，十进制就是*2咯
带符号右移： >> 
同上，逆运算，就是在高位补0或1
无符号右移： >>>  高位补0




快速幂：
int q_pow(int a,int b){
  int r=1,base=a;
  while(b){
    if(b&1) r*=base;
    base*=base;
    b>>=1;
  }
  return r;
}


2017年4月26日19:51:03
scanf有返回值
while(scanf()!=EOF)实现过程：
int a;
    int s[20]={0};
    aa:
        switch(scanf("%d",&a)){
            case 0: getchar();goto aa;
            case -1:goto bb;
            default:if(a<=9&&a>=0)s[a]++;goto aa;
        }
    bb:
        for(int i = 0; i < 20; i++)
            printf("%d\n",s[i]);








/*使用姿势：
bool next_permutation( iterator start, iterator end );
返回值：如果下一个排列字典序更大，返回true，否则返回false
*/
#include
#include
using namespace std;
char s[5]="1234";
int main()
{
    printf("%s\n", s);
    while(next_permutation(s,s+4))
    {
        printf("%s\n", s);
    }
}




矩阵入门：
加法减法，数乘：对应位置操作;

矩阵转置：符号A^T ：行列互相交换（以左上角右下角连线为轴，翻转矩阵）

2017年6月6日19:36:31
(a/b)%mod!=(a%mod)/(b%mod)
(a/b)%mod==a%(b*mod)/b%mod

rev(a) = (p-p/a)*rev(p%a)%p