CCF

。。。为什么50分。。啊暂时不想改了 换别人的思路吧

#include<bits/stdc++.h>  别看这个了 太曲曲绕绕
using namespace std;

int r,y,g;
int n;


int change1(int sign,int number){
     if(sign==1){
           return number;
     }else if(sign==2){
         return number+r;
     }else{
        return 0;
     }
}
//红绿灯颜色变化是 红绿黄  但是sign按顺序是红黄绿!!!!!!!!!!!!!
int change2(long long sum,int sign,int number){//参数类型
     int remain = 0;

     if(sign==1){//原本是红灯
         if(number+g > sum){ //过来的时候 在本轮绿灯
            sum = sum;
            return sum;
         }else if(number+y+g>sum){//过来的时候 在本轮黄灯
            sum += y-(sum-number-g);
            return sum;
         }else{//时间超出较多 已过本轮红绿黄
            remain = sum-number-y-g;
         }
     }else if(sign==3){//原本是绿灯
        if(number+y>sum){//过来的时候 在本轮黄灯
            sum += y-(sum-number);
            return sum;
        }else{//时间超出较多 已过本轮绿黄
            remain = sum-number-y;
        }
     }else{//原本是黄灯
           remain = sum - number;
     }

      //其他轮开始
      int complete = r+g+y;
      int still = remain%complete;
      if(still>=0 && still<r){//红
              sum += (r-still);
      }else if(still>=r && still<r+g){//绿
              sum = sum;
      }else if(still>=r+g && still<r+g+y){//黄
              sum += (y-(still-r-g))+r;
      }


        return sum;

}
int main(){


     cin>>r>>y>>g;
     cin>>n;
     int data[n][2];
     long long sum = 0;
     for(int i=0;i<n;i++){
        cin>>data[i][0]>>data[i][1];
     }
    //
    for(int i=0;i<n;i++){
        if(data[i][0]==0){
            sum += data[i][1];
        }else{
            if(sum < data[i][1]){
                sum += change1(data[i][0],data[i][1]);
            }else{ //换灯
                 sum = change2(sum,data[i][0],data[i][1]);
            }

        }
    }

     cout<<sum<<endl;

     return 0;
}
//https://blog.csdn.net/happywlg123/article/details/87864575
//其实是和我不太一样的思路 他是不分本轮还是其他论 到了路口直接取模运算 认为从到了路口那个节点开始算起再到那个节点 算一圈
//我的是从红灯开始的那一秒 算一个轮回 所以我的要分的情况更多一些
//50啊到底哪里错了   sum要用long long类型的传参的时候也是这样

 尼玛 时隔几个月在做

又看了看别人的

怎么说呢 反正思路不难 并且用我隐藏的函数的话得分是60分  换了个写法(也相当于思路变了点 不用划分轮数啊)就100了

#include<bits/stdc++.h>
using namespace std;
int rtime,ytime,gtime;
int roundtime;
struct d{
     int signal;
     int wastetime;
};
//int cornerwaste(long long sumtime,int ding1,int ding2){//计算在这个路口等待多少时间
//
//     if(sumtime<ding2){//还在这个灯下
//         //cout<<"22"<<endl;
//         switch(ding1){
//         case 1:return ding2-sumtime;
//         case 2:return ding2-sumtime+rtime;
//         case 3:return 0;
//         }
//     }else{//切换到其他灯
//         //cout<<"11"<<endl;
//         int p1 = sumtime-ding2;
//         int still = p1%roundtime;//cout<<"still"<<endl;
//         switch(ding1){
//         case 1:{//该时刻是红灯
//             if(still<gtime){//卡在绿灯了
//                return 0;
//             }else if(still<gtime+ytime){//卡在黄灯
//                 return rtime+ytime-(still-gtime);
//             }else{//卡在红灯
//                 return rtime-(still-ytime-gtime);
//             }break;
//         }
//         case 2:{//该时刻是黄灯
//             if(still<rtime){//卡在红灯了
//                return rtime-still;
//             }else if(still<gtime+rtime){//卡在绿灯
//                 return 0;
//             }else{//卡在黄灯
//                 return ytime-(still-gtime-rtime)+rtime;
//             }break;
//         }
//         case 3:{//该时刻是绿灯
//             if(still<ytime){//卡在黄灯了
//                return ytime-still+rtime;
//             }else if(still<ytime+rtime){//卡在红灯
//                 return rtime-(still-ytime);
//             }else{//卡在绿灯
//                 return 0;
//             }break;
//         }
//         }
//     }
//}
// https://blog.csdn.net/happywlg123/article/details/87864575
//思路都是一样的 所以不用分他来到红绿灯前此时是本轮还是过了n轮 也就是说不用最外面这个ifelse
//直接合并就好
int cornerwaste(long long sumtime,int ding1,int ding2){
            int still = sumtime%roundtime;//剩的时间
            switch(ding1){
             case 1:{//原来是红灯
                 if(still<ding2){//没换灯
                    return ding2-still;
                 }else if(still>=ding2&&still<ding2+gtime){
                     return 0;
                 }else if(still>=ding2+gtime&&still<ding2+gtime+ytime){
                     return rtime+ytime-(still-gtime-ding2);
                 }else if(still>=ding2+gtime+ytime&&still<ding2+gtime+ytime+rtime){
                     return rtime-(still-gtime-ding2-ytime);
                 }

             }
             case 2:{//原来是黄灯
                  if(still<ding2){//没换灯
                    return ding2-still+rtime;
                 }else if(still>=ding2&&still<ding2+rtime){
                     return rtime-(still-ding2);
                 }else if(still>=ding2+rtime&&still<ding2+gtime+rtime){
                     return 0;
                 }else if(still>=ding2+gtime+rtime&&still<ding2+gtime+ytime+rtime){
                     return rtime+ytime-(still-gtime-ding2-rtime);
                 }

             }
             case 3:{//原来是绿灯
                 if(still<ding2){//没换灯
                    return 0;
                 }else if(still>=ding2&&still<ding2+ytime){
                     return rtime+ytime-(still-ding2);
                 }else if(still>=ding2+ytime&&still<ding2+rtime+ytime){
                     return rtime-(still-ytime-ding2);
                 }else if(still>=ding2+rtime+ytime&&still<ding2+gtime+ytime+rtime){
                     return 0;
                 }

             }
         }



}
int main(){

     cin>>rtime>>ytime>>gtime;roundtime=rtime+ytime+gtime;
     int n;cin>>n;
     d ding[n];
     long long sumtime=0;
     for(int i=0;i<n;i++){
        cin>>ding[i].signal>>ding[i].wastetime;
     }
     for(int i=0;i<n;i++){
        switch(ding[i].signal){
           case 0:{sumtime+=ding[i].wastetime;break;}
           default:{sumtime+=cornerwaste(sumtime,ding[i].signal,ding[i].wastetime);break;}
        }
     }
      cout<<sumtime<<endl;
      return 0;

}

----------------

CCF 20200902风险人群筛查

关于头部的书写：https://blog.csdn.net/weixin_45919985/article/details/109011277#include<bits/stdc++.h>

#define TLE ios::sync_with_stdio(0),cin.tie(0)//！！！！！
#define long long ll
const int INF = 0x3f3f3f3f;
const int maxn = 10005;
using namespace std;
struct Node{
    int x, y;
}node[maxn];
int main(){
    TLE;
for(int i = 1;i<=n;i++){
 memset(node,0,sizeof(node)); //
 for(int j = 1;j<=t;j++){ 
 cin>>node[j].x>>node[j].y; 
}
}

memset是计算机中C/C++语言初始化函数。作用是将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作。逐字节拷贝

void *memset(void *str, int c, size_t n)

• str -- 指向要填充的内存块。
• c -- 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
• n -- 要被设置为该值的字符数。

不能用它给char以外的数组赋值时初始化为0和-1之外的其他值  

对于int数组初始化为0：int a[20] = {0};

如果要把一个char a[20]清零，一定是 memset(a,0,20*sizeof(char));

 char buffer[]="Helloworld
";
 memset(buffer,'*',strlen(buffer));:strlen:返回字符串的长度

int array[5]={1,4,3,5,2};
memset(array,0,5*sizeof(int));

char str[50];
strcpy(str,"This is string.h library function");
puts(str);
memset(str,'$',7);
puts(str);

This is string.h library function
$$$$$$$ string.h library function

结构体：不能在结构体声明中初始化结构体成员

如果某个结构成员未被初始化，则所有跟在它后面的成员都需要保留为未初始化。使用初始化列表时，c++不提供跳过成员的方法

1. struct Date
2. {
3. int day, month, year;
4. };
5. Date birthday = {23, 8, 1983};

#include<bits/stdc++.h>
using namespace std;
int main(){

  int n,k,t,xl,yd,xr,yu;
  cin>>n>>k>>t>>xl>>yd>>xr>>yu;
  int trip[t][2];//每个居民 t个时刻的足迹
  int stay = 0;//逗留
  int pass = 0;
  int passtime = 0;
  bool continuation= false;
  bool already = false;
  for(int i=0;i<n;i++){
    //一个新的居民
    passtime = 0;
    continuation= false;
    already = false;
     for(int j=0;j<t;j++){
        cin>>trip[j][0]>>trip[j][1];//一个居民的足迹 计算
        if(trip[j][0]>=xl&&trip[j][0]<=xr&&trip[j][1]>=yd&&trip[j][1]<=yu){//此时刻经过
            //上一个时刻也经过
            if(continuation){
                passtime++;
            }else{//上一个时刻没经过
                passtime = 1;
            }
            continuation = true;
        }else{ //本时刻没经过
            continuation = false;
        }

        if(passtime>=k){
           // cout<<"go out"<<endl;
            already = true;//直接就跳出去了 这时候可能足迹还没有输完 就算下一个人的了
        }
     }
     if(already){
        stay++;
     }

     if(passtime>0){
        pass++;
     }
    //我靠！！！！气我了吧 这个题意说的这么啊啊啊啊啊啊啊啊啊啊啊 逗留属于经过！！是两个if的关系而不是else if
    //qswl qswl qswl在考场上找bug的我是个shab啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
     //万一人压根没经过呢
  }
  cout<<pass<<endl;
  cout<<stay<<endl;



  return 0;
}

-------------------------

20200601 线性分类器

#include<bits/stdc++.h>
using namespace std;
//两点在直线的同一侧，则其代入方程的值正负相同
struct dian{
  int xi;
  int yi;
  char typei;
};
int main(){

 int n,m;
 cin>>n>>m;
 struct dian node[n] ;
 for(int i=0;i<n;i++){
   cin>>node[i].xi>>node[i].yi>>node[i].typei;
 }

 int o0,o1,o2;
 char above;
 bool answer[m];
 for(int k=0;k<m;k++){
    answer[k] = true;
 }
 for(int k=0;k<m;k++){
    cin>>o0>>o1>>o2;//判断该直线是否能分离开AB
    above = 'c';
    long stand = o0+o1*node[0].xi+o2*node[0].yi;
    long temp;
    for(int i=0;i<n;i++){
        temp = o0+o1*node[i].xi+o2*node[i].yi;
        if(i==0){//由第一个节点的类型规定谁在上面
            if(stand>0){//在直线上面
               above = node[0].typei;
            }
            else{
               if(node[0].typei=='A'){
                  above = 'B';
               }else{
                  above = 'A';
               }
            }
        }
        else if(temp>0){//在直线上面
            if(node[i].typei!=above){
                answer[k]=false;
            }
        }else{//在直线下面
            if(node[i].typei == above){
                answer[k]=false;
            }
        }
    }
 }

 for(int k=0;k<m;k++){
    if(answer[k]){
        cout<<"YES"<<endl;
    }else{
       cout<<"NO"<<endl;
    }
 }



 return 0;
}

emmm暂时还没有看出来为啥0分。。。。。。。。。。。。。。。。。。。。。。。。。。很简单因为没看清输出要求的大小写 改了之后满分

 。。。。。。。附上最近做的 妈蛋为啥0分啊混蛋

大神的代码：https://blog.csdn.net/waveleting/article/details/108468175?utm_medium=distribute.pc_relevant.none-task-blog-title-5&spm=1001.2101.3001.4242

看清楚：划定标定值 long long standard = points_a[0].x * lines[i].a + points_a[0].y * lines[i].b + lines[i].c; 是直接拿的A组容器中的第一个作为标准 而不是这些数据点的第一个 【无所谓】

对vector的应用：https://www.runoob.com/w3cnote/cpp-vector-container-analysis.html

vector<int>obj;//创建一个向量存储容器 int 这就是创建了
   for(int i=0;i<10;i++) // push_back(elem)在数组最后添加数据 
    {
        obj.push_back(i);
        cout<<obj[i]<<",";    
    }

vector<point> points_a;
vector<point> points_b;
vector<line> lines;

if (type == 'A')
 points_a.push_back(temp);
else points_b.push_back(temp);

struct student类似于int，teacher就是变量

 

20200602 稀疏向量

#include<bits/stdc++.h>
using namespace std;
#define TLE ios::sync_with_stdio(0),cin.tie(0)
//内积:对这两个向量对应位一一相乘之后求和的操作
int main(){
  TLE;
  long n,a,b;
  cin>>n>>a>>b;//两数组维度相同  //数组下标从1开始 如何处理
  long u[n+1]={0};
  long v[n+1]={0};
  long x,y;
  for(long i=0;i<a;i++){
    cin>>x;
    cin>>y;
    u[x] = y;
  }
  for(long i=0;i<b;i++){
    cin>>x;
    cin>>y;
    v[x] = y;
  }

  long long sum = 0;
  for(long i=0;i<=n;i++){
     if(u[i]!=0&&v[i]!=0){
        sum+=u[i]*v[i];
     }
  }
  cout<<sum<<endl;

  return 0; //即使改了类型 当n越来越大还是超时 从而得知ap是存储稀疏矩阵的最好形式
}

改为:

#include<bits/stdc++.h>
using namespace std;
#define TLE ios::sync_with_stdio(0),cin.tie(0)
//问题分析：map用于存储稀疏数据是最有效的，也可以用来存储稀疏向量。
//2个向量不必都存储，能够边读入数据边计算可以节省存储，也有助于提高计算速度。
//先读入数据存储在数据结构中，再进行处理是倒腾，既浪费存储又浪费时间，完全没有必要。
int main(){
  TLE;
  long n,a,b;
  cin>>n>>a>>b;
  long long sum = 0;
  map<int,int> m;
  int x,y;
  for(int i=1;i<=a;i++){
    cin>>x>>y;
    m[x]=y;//map的一种赋值方式：数组赋值
  }
  for(int j=1;j<=b;j++){
    cin>>x>>y;
    cout<<"m[x] "<<m[x]<<endl;
    sum+=y*m[x];
    //!!!这步绝了 m[x]map查找 如果有就乘 如果没有就是默认值0
  }
  cout<<sum<<endl;

  return 0;
}
/*
10 3 4
4 5
7 -3
10 1
1 10
4 20
5 30
7 40
*/

map默认值

如果为基本数据类型，map一般value值默认为0，‘’

map默认排序

基本数据类型的map默认为key值降序排列

map

https://www.cnblogs.com/fnlingnzb-learner/p/5833051.html   https://www.w3cschool.cn/cpp/cpp-fu8l2ppt.html

构造：通常用如下方法构造一个map：map<int, string> mapStudent;

插入：mapStudent.insert(pair<int, string>(1, "student_one"));   / mapPerson[3] = "Jerry"; 【3是key值】/  

           mapStudent.insert(map<int, string>::value_type (1, "student_one"));  当map中有这个关键字时，insert操作是插入数据不了的，但是用数组方式就不同了，它可以覆盖以前该关键字对 应的值

迭代：先构造迭代器

前向迭代

std::map < int ,std::string > ::iterator it;
std::map < int ,std::string > ::iterator itEnd;
it = mapPerson.begin();
itEnd = mapPerson.end();
while (it != itEnd) {
   cout<<it->first<<' '<<it->second<<endl;  
   it++;
}

后向迭代

std::map < int, string > ::reverse_iterator iter;  
for(iter = mapPerson.rbegin(); iter != mapPerson.rend(); iter++) 
    cout<<iter->first<<"  "<<iter->second<<endl;  

 查找：

find函数 返回一个迭代器  指向键值为 key 的元素，如果没找到就返回指向 map 尾部的迭代器。

map<int ,string > ::iterator l_it;//所以必须先声明一个迭代变量作为返回值
   l_it = maplive.find(112);
   if(l_it == maplive.end())
                cout<<"we do not find 112"<<endl;
   else cout<<"wo find 112"<<l_it->second<<endl;
//it->first得到key  it->second得到second https://blog.csdn.net/aqzwss/article/details/42397843

大小：Int nSize = mapStudent.size();

关于map<int, string>::iterator iter; 这声明的是一个迭代器 https://bbs.csdn.net/topics/360018701

这里的iterator是在template class map中声明的一个类，所以需要用map<int, string>::iterator，来声名，因为在global作用域里面找不到iterator的定义。map<int, string>用来指名iterator的作用域map<int, string> iter  iter则是template class map的一个实例化的实例，其中第一个模板参数是int类型，第二个则是string。

// map另一种使用方法
int main(){
  TLE;
  long n,a,b;
  cin>>n>>a>>b;
  long long sum = 0;
  map<int,int> m;
  int x,y;
  for(int i=1;i<=a;i++){
    cin>>x>>y;
    m.insert(pair<int,int>(x,y));
  }
  map<int,int>::iterator iter,iter1;
  //iter1 = m.begin();
  for(int j=1;j<=b;j++){
    cin>>x>>y;
    iter = m.find(x);
    if(iter!=m.end()){
         sum+=y* iter->second ;
    }
  }
  cout<<sum<<endl;

  return 0;
}

类型数值范围

对于浮点说而言：使用double类型基本上不会有错。在float类型中隐式的精度损失是不能忽视的

20170901 打酱油

#include<bits/stdc++.h>
#define TLE ios::sync_with_stdio(0),cin.tie(0)
using namespace std;
//尽可能以５瓶一组来买(50/7 轮下来一瓶单价低啊)，余下的部分尽可能以３瓶一组来买(30/4)，最后剩下的部分按１０元一瓶来买。
int main(){
  TLE;
 /*
  int N;cin>>N;
  int sum = 0;
  if(N==10||N==20){
      cout<<(N/10)<<endl;
  }else if(N==30||N==40){
      cout<<(N/10+1)<<endl;
  }else if(N==50||N==60||N==70){
      cout<<(N/10+2)<<endl;
  }else{
     int have5 = N/50;
     sum+= (7*have5);
     int yu = N % 50;//模运算是%啊
     if(yu==30){
        sum+=4;
        cout<<sum<<endl;
     }else{
        sum+=yu/10;
        cout<<sum<<endl;
     }

  }
  */ //有了这个思路后 直接简化：
    int n,count=0;
    cin >> n;
    count = (n / 50) * 7 + ( (n % 50) / 30)  *4+(n % 50)%30/10;
    cout << count << endl;
    return 0;
}

 20170902 公共钥匙盒

题目的核心是把每一个上下课表示成两个取放钥匙的动作，然后对动作进行排序。

题目分析
1.对操作进行模拟。对于操作顺序，题目中很明确给出每次还钥匙的时候，还到最左边的空位上，如果同时还钥匙，按照编号还，如果同时取和还，先还再取。那么这么一看就是三重结构体排序。对于结构体的构建，需要三个属性：操作时间，操作钥匙编号，操作标志。看好，这里是操作时间，并不是取钥匙时间和还钥匙时间，是放在一起啦，所以是操作时间。因此，对于每一个输入，都需要把输入变成两个操作，取钥匙和还钥匙。例如对于输入4 3 3 ，则分解成id=4,s=3,flag=0和id=4,e=3+3=6,flag=1.只要将全部输入变成全部操作后，才能利用结构体排序。结构体排序按照操作时间，操作标志，要是编号进行排序。
2.对钥匙进行模拟。操作顺序确定后，就要对钥匙进行模拟，无非就是取钥匙和还钥匙。在取钥匙时，对于相应的位置，置为0，代表空。还钥匙时从左到右遍历一遍，找到第一个空位置，将编号重置即可。大佬：https://blog.csdn.net/zhanggirlzhangboy/article/details/78208005 【用的是普通队列】

【优先队列】

#include<bits/stdc++.h>
using namespace std;

struct use{

     int num;
     int over;
     friend bool operator <(use a,use b){
         return a.over > b.over;
     }

};
priority_queue<use> q;//以使用结束的时间作为优先级 由小到大排序

int main(){

     int n,k;
     cin>>n>>k;
     use a;
     int isuse[n]={0};//没用过
     map<int,int> maps;
     int w,s,c;
     for(int i=1;i<=k;i++){
        cin>>w>>s>>c;
        maps[w]=s+c;
        isuse[w]=1;//用着 用过
     }
     map<int,int>::iterator iter;
     for(iter=maps.begin();iter!=maps.end();iter++){
        //cout<<iter->first<<" "<<iter->second<<endl;
        a.num=iter->first;
        a.over=iter->second;
        q.push(a);
     }


     for(int i=1;i<=n;i++){
        if(isuse[i]==0){//没用过
            cout<<i<<" ";
        }else{
            if(!q.empty())
            {
                a=q.top();
                cout<<a.num<<" ";
                q.pop();
            }
        }
     }

    return 0;

}

20170301 分蛋糕

#include<bits/stdc++.h>
using namespace std;

int main(){

  int n,k;
  cin>>n>>k;
  int cake[n];
  int friendsum=0;
  int cakesum=0;
  for(int i=0;i<n;i++){
     cin>>cake[i];
  }//有多少个盆友这个不用管
  for(int i=0;i<n;i++){
    if(cake[i]>=k||i==(n-1)){//满足 ??
       friendsum++;
    }else{
       cakesum=cake[i];
       for(int j=i+1;j<n;j++){
         cakesum+=cake[j];
         if(cakesum>=k||j==(n-1)){
            friendsum++;
            i=j;
            break;
         }
       }

    }
  }
  cout<<friendsum<<endl;


  return 0;
}

20161201 中间数 

#include<bits/stdc++.h>
#define TLE ios::sync_with_stdio(0),cin.tie(0)
using namespace std;

int main(){
  TLE;
  int n;
  cin>>n;
  int arraya[n];
  for(int i=0;i<n;i++){
    cin>>arraya[i];
  }
  sort(arraya,arraya+n);//不行就老老实实找
  int ssum=0;
  int dsum=0;
  int aver=0;
  if(n%2!=0){
     aver = arraya[n/2];
     for(int i=0;i<(n/2);i++){
        if(arraya[i]<aver){
            ssum++;
        }
     }
      for(int i=n-1;i>(n/2);i--){
        if(arraya[i]>aver){
            dsum++;
        }
     }
   if(dsum==ssum){
       cout<<aver;
   }else{
       cout<<"-1"<<endl;
   }
  }
//基数个：是否存在 排序后中间数不是 左右的数是中位数的情况：不存在 【最中间那个数 要么是要么不是】
  else{
     aver = arraya[n/2];
     for(int i=0;i<(n/2);i++){
        if(arraya[i]<aver){
            ssum++;
        }
     }
      for(int i=n-1;i>(n/2);i--){
        if(arraya[i]>aver){
            dsum++;
        }
     }
   if(dsum==ssum){
       cout<<aver;
   }else{
       aver = arraya[n/2+1];
       ssum=0;dsum=0;
       for(int i=0;i<(n/2);i++){
        if(arraya[i]<aver){
            ssum++;
         }
       }
       for(int i=n-1;i>(n/2);i--){
        if(arraya[i]>aver){
            dsum++;
        }
       }
      if(dsum==ssum){
           cout<<aver;
     }else{
         cout<<"-1"<<endl;
     }
   }

}
  return 0;
}
//同理 偶数个：该值只可能在【n/2】和【n/2+!】这俩中间值之间 别的不可能
// 1 2 3 3 3 3 4 4 5     2 3 5 5 5 6 6 去除重复也不行

20170302 学生排队

//20170302 学生排队
#include<bits/stdc++.h>
using namespace std;
#define TLE ios::sync_with_stdio(0),cin.tie(0)
int findindex(int stunum[], int num,int n){
     for(int i=0;i<n;i++){
        if(num==stunum[i]){
            return i;
        }
     }

}
int main(){

      int n;
      cin>>n;
      int stunum[n];
      for(int i=0;i<n;i++){
        stunum[i] = i+1;
      }
      int req;
      cin>>req;
      int num;int walk;int index;
      for(int i=0;i<req;i++){
        cin>>num>>walk;
        //依照学号找到下标
        index = findindex(stunum,num,n);
        //cout<<index<<endl;
        int temp[abs(walk)+1] = {0};//要改动的数组的大小
        if(walk>0){
            for(int i=0;i<walk;i++){
                temp[i] = stunum[index+1+i];
            }
            temp[walk] = stunum[index];
            //temp数组弄到stunumm上
            for(int i=0;i<walk+1;i++){
                stunum[index+i] = temp[i];
            }


        }else{//往后移
            walk = abs(walk);
            for(int i=walk;i>0;i--){
                temp[i] = stunum[index-(walk-i)-1];
            }
            temp[0] = stunum[index];
            for(int i=0;i<walk+1;i++){
                stunum[index-walk+i] = temp[i];
            }

        }

      }
      for(int i=0;i<n;i++){
        cout<<stunum[i]<<" ";
      }


}
 //数组输出 这输出的是地址cout<<stunum<<endl;
/*在向后移动时，移动的距离不超过对应同学后面的人数，如果向后移动的距离正好等于对应同学后面的人数则该同学会移动到队列的最后面。在向前移动时，移动的距离不超过对应同学前面的人数，如果向前移动的距离正好等于对应同学前面的人数则该同学会移动到队列的最前面。
这个没啥 代码该咋写咋写
*/

 20161202 工资计算 

天哪完全做复杂了 我倒着推的 费了半天劲

#include<bits/stdc++.h>
using namespace std;
#define TLE ios::sync_with_stdio(0),cin.tie(0)

int main(){
    TLE;
    int after = 0;
    cin>>after;
    int before = 0;
    //必须要交45 300 900 6500 6000 8750 后 再交超过80000元的部分，税率45%；
    int rank8 = 1500*0.03+(4500-1500)*0.1+(9000-4500)*0.2+(35000-9000)*0.25+(55000-35000)*0.3+(80000-55000)*0.35;
    //必须要交45 300 900 6500 6000 后 再交超过55000元未超过80000元的部分，税率35%；
    int rank7 = 1500*0.03+(4500-1500)*0.1+(9000-4500)*0.2+(35000-9000)*0.25+(55000-35000)*0.3;
    //必须要交45 300 900 6500 后 再交超过35000元未超过55000元的部分，税率30%；
    int rank6 = 1500*0.03+(4500-1500)*0.1+(9000-4500)*0.2+(35000-9000)*0.25;
    //必须要交45 300 900 后 再交超过9000元未超过35000元的部分，税率25%；
    int rank5 = 1500*0.03+(4500-1500)*0.1+(9000-4500)*0.2;
    //必须要交45 300 后再交超过4500元未超过9000元的部分，税率20%；
    int rank4 = 1500*0.03+(4500-1500)*0.1;
    //必须要交45 后再交超过1500元未超过4500元的部分，税率10%；
    int rank3 = 1500*0.03;
    //交不到45
    int rank2;
    //不用交
    int rank1;

    //所有评测数据保证小明的税前工资为一个整百的数
    //这句话保证在交完税后还是这个等级阶层
    if(after<=3500){
        before = after;
    }else if(after<=3500+1500){
        before = (after-3500*0.03)/97*100;
    }else if(after<=3500+4500){
        after = after+rank3;
        before = after-0.1*(3500+1500);
        before = before/90*100;
    }else if(after<=3500+9000){
        after = after+rank4;
        before = after-0.2*(3500+4500);
        before = before/80*100;
    }else if(after<=3500+35000){
        after = after+rank5;
        before = after-0.25*(3500+9000);
        before = before/75*100;
    }else if(after<=3500+55000){
        after = after+rank6;
        before = after-0.3*(3500+35000);
        before = before/70*100;
    }else if(after<=3500+80000){
        after = after+rank7;
        before = after-0.35*(3500+55000);
        before = before/65*100;
    }else{
        after = after+rank8;
        before = after-0.45*(3500+80000);
        before = before/55*100;
    }
    cout<<before;
    return 0;
}
//我想说的一个地方就是 金融计算绝对不能用浮点数 /小数 比如8000/0.2=9999 所以转换成 8/20*100就ok
//小数不成就转换成整数嘛

如果有大佬也是倒着推的请告诉我为啥只有70分 

其实数据量不大啊 对于所有评测用例，1 ≤ T ≤ 100000。 工资最高10万 并且所有评测数据保证小明的税前工资为一个整百的数。 +100+100的增加一个个比对暴力破解也行的

关键是没想到 想了下觉得程序进不去啥的

总体思路是顺推，就从税前工资开始计算税后工资，当计算的税后工资与输入的T相等时退出循环。

for(i = 3600; i <= 200000; i=i+100)//100 100的增加
{
    int x = 0; //x记录扣掉的钱
    if(i >= 3600 && i <= 5000)
    {
        x += (i-3500)*0.03;
    }
    if(i >= 5100 && i <= 8000)
    {
        x += (i-5000)*0.1+45;
    }
    if(i >= 8100 && i <= 12500)
    {
        x += (i-8000)*0.2+45+300;
    }
    if(i >=12600 && i <= 38500)
    {
        x += (i-12500)*0.25+45+300+900;
    }
    if(i >= 38600 && i <= 58500)
    {
        x += (i-38500)*0.3+45+300+900+6500;
    }
    if(i >= 58600 && i <= 83500)
    {
        x += (i-58500)*0.35+45+300+900+6500+6000;
    }
    if(i >= 83600)
    {
        x += (i-83500)*0.45+45+300+900+6500+6000+8750;
    }
    if(i-x == t) //t是税后
    {
        cout<<i<<endl;
        break;//!!!
    }
}

还是看下这个大佬的：https://tigerisland.blog.csdn.net/article/details/54799557?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control 给大佬打call

/* CCF201612-2 工资计算 */

#include <iostream>

using namespace std;

//#define DEBUG

int salaryrange[] = {3500, 3500+1500, 3500+4500, 3500+9000, 3500+35000, 3500+55000, 3500+80000 };
int taxrate[] = {3, 10, 20, 25, 30, 35, 45};
const int SIZE = sizeof(salaryrange) / sizeof(int);

int range[SIZE];

int main()
{
    int t, s;

    // 计算各种收入范围
    range[0] = salaryrange[0];
    for(int i=1; i<SIZE; i++) {
        range[i] = range[i-1] + (salaryrange[i] - salaryrange[i-1])- (salaryrange[i] - salaryrange[i-1]) * taxrate[i-1] / 100;
    }

#ifdef DEBUG
    for(int i=0; i<SIZE; i++)
        cout << range[i] << " ";
    cout << endl;
#endif
//在工程设置里有一些设置会对该工程自动产生一系列的宏，用以控制程序的编译和运行。
//就好象楼上说的一样，如果你把代码夹在#ifdef DEBUG 和对应的 #endif 中间，那么这段代码只有在调试（DEBUG）下才会被编译。
//也就是说，如果你在RELEASE模式下，这些代码根本就不会存在于你的最终代码里头。


    // 输入数据：
    cin >> t;

    // 计算收入范围
    int i;
    for(i=0; i<SIZE; i++)
        if(t <= range[i])
            break;

    // 计算税前工资
    if(i == 0)
        s = t;
    else {
        s = salaryrange[i-1] + (t - range[i-1]) * 100 / (100 - taxrate[i-1]);
    }

    // 输出结果
    cout << s << endl;

    return 0;
}

20160402 俄罗斯方块

#include<bits/stdc++.h>
using namespace std;
#define TLE ios::sync_with_stdio(0),cin.tie(0)

int after[15][10];
int block[4][4];
int col;
int split[15][4];
int truelength;

bool compare(int hei){ //hei+1==现实的行数
    for(int i=0;i<truelength;i++){
        for(int j=0;j<4;j++){
            if(block[i][j]==1){
                if(split[hei-truelength+1+i][j]==1){
                   return false;
                }
            }
        }
    }
    return true;
}
int main(){
    TLE;
    for(int i=0;i<15;i++){
        for(int j=0;j<10;j++){
            cin>>after[i][j];
        }
    }
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            cin>>block[i][j];
        }
    }
    cin>>col;

    bool result;

    for(int i=0;i<15;i++){
        for(int j=0;j<4;j++){
            split[i][j] = after[i][col-1+j];
        }
    }//cout<<endl;
//    for(int i=0;i<15;i++){
//        for(int j=0;j<4;j++){
//            cout<<split[i][j]<<" ";
//        }cout<<endl;
//    }

    //模块block是不能左右移动的但是他的下面可能会有几行0行 直接在这删掉
    int canreduce=0;
    int z=0;
    for(int i=3;i>0;i--){
        for(z=0;z<4;z++){
            if(block[i][z]==1){
                break;
            }
        }
        if(z==4){
            canreduce++;
        }else{
            break;
        }
    }
    //cout<<"canreduce:"<<canreduce<<endl;
    truelength = 4 - canreduce;//block的真实高度
   // cout<<"truelength:"<<truelength<<endl;


    int hei = 0;
    for(int i=4;i<15;i++){//输入保证前4行中的数字都是0。要比较的话从第五行开始
        //块和块之间作比
        if(!compare(i)){//这一行不行了
            //那么上一行是可以的
            hei = i-1;
           // cout<<"hei: "<<hei<<endl;
            break;
        }
        hei = i;
    }
  //  cout<<"hei: "<<hei<<endl;


    //赋予新值
    for(int i=0;i<truelength;i++){
        for(int j=0;j<4;j++){
            if(block[i][j]==1){
                after[hei-truelength+1+i][col-1+j] = 1;
            }
        }
    }

    for(int i=0;i<15;i++){
        for(int j=0;j<10;j++){
            cout<<after[i][j]<<" ";
        }
        cout<<endl;
    }




    return 0;
}

20160902 火车购票

#include<bits/stdc++.h>
using namespace std;
#define TLE ios::sync_with_stdio(0),cin.tie(0)
//bool seted[100] = {0};//bool数组初始化 https://blog.csdn.net/u012223913/article/details/51176071
// bool seted[100];memset(seted,0,sizeof(seted));
int seats[20][5];
int n;
bool have_continuous_seats(int hei,int purchase){ //判断该行是否有连续的 / 安排在最小并输出改变
     //cout<<"hei: "<<hei<<"purchase: "<<purchase<<endl;
    // cout<<"continuous--k: "<<purchase<<endl;
     int i,z;
     for(i=0;i<5;i++){//i:起点块 z:跟在i后面的块
        if(seats[hei][i] == 0){//当前还没被占用
            //cout<<"continuous--i: "<<i<<endl;
            for(z=1;z<purchase&&(i+z)<5;z++){
                //cout<<"i+z: "<<(i+z)<<" ";//操啊这个值超出数组了也还是0
                if(seats[hei][i+z]==1){
                   // cout<<"is 1"<<endl;
                    break;//某块被占用 这个起点i不行
                }
            }//cout<<endl;
            //cout<<"z: "<<z<<endl;
            if(z==purchase){//这个起点i可以
                //cout<<"come in"<<endl;
               // cout<<"i: "<<i<<endl;
                for(z=i;z<i+purchase;z++){
                   seats[hei][z] = 1;
                   //输出座位号 得转换
                   //cout<<"hei: "<<hei<<" z"<<z<<endl;
                   cout<<(hei*5+z+1)<<" ";
                }cout<<endl;
                return true;
            }

        }//else这个起点被占用换下一个
     }
     if(i==5){
        return  false;//这一行不行
     }

}
void have_separate_seats(int purchase){
    int i,j,z,k=0;
    for(i=0;i<20;i++){
        for(j=0;j<5;j++){
            if(seats[i][j]==0){//这个块还没被占用
                    seats[i][j]==1;
                    k++;
                    cout<<((i-1)*5+j+1)<<" ";
            }
            if(k==purchase){
               goto label;//无条件转移到同一函数内的被标记的语句。
            }

        }
    }
    label: cout<<endl;//同一函数内

}
int main(){

     TLE;
     cin>>n;//购票的指令数
     int require[n];
     for(int i=0;i<n;i++){
        cin>>require[i];//每个整数p在1到5之间，表示要购入的票数
     }
     for(int i=0;i<20;i++){
        for(int j=0;j<5;j++){
            seats[i][j] = 0;//表示都还没被占用
        }
     }

     //要求：能相邻最好相邻 不能的话全部安排在前面
     int i,j,k,purchase;
     for(k=0;k<n;k++){
        purchase = require[k];//得到这个人要买的票数
        //cout<<"purchase:"<<purchase<<endl;
        //先安排连续的座位
        for(i=0;i<20;i++){
            if(have_continuous_seats(i,purchase)){//有的话在该函数里改变输出 处理下个购票
                    break;
            }
        }
        if(i==20){//安排离散的位置 从头到尾一个个扫描 见到一个空的就插入
            //cout<<"separate--k: "<<purchase<<endl;
            have_separate_seats(purchase);

        }
        //cout<<endl;
        //cout<<endl;
     }
     return 0;
}

20201202

关于两组数据的排序【一般都会想到用二维数组表示 还可以用结构体 如下 】使用结构体表示排序 +vector begin()/end()+sort函数 很快速出来排序

#include<bits/stdc++.h>
using namespace std;

typedef struct example
{
    int elem1;
    int elem2;
}example;

/*这个comparison函数很重要.如果希望升序排序,就是"<",降序排列就是">"号,这样便于直观记忆.
如果希望用elem2作为比较标准就把elem1改为elem2,这样结构体就以elem2为比较标准排序了.*/
bool comparison(example a,example b){
    return a.elem1<b.elem1;
}

int main()
{
    int N;
    cin>>N;

    vector<example> arrayy(N); //!! 这里新建数组是（）不是【】

    for(int i=0;i<N;i++)
    {
        cin>>arrayy[i].elem1>>arrayy[i].elem2;
    }

    sort(arrayy.begin(),arrayy.end(),comparison);

    for(int i=0;i<N;i++)
    {
        cout<<arrayy[i].elem1<<" "<<arrayy[i].elem2<<endl;
    }
        return 0;
}

 首先看到n为10^5,两层循环肯定是超时的，只能得70分！

我们需要一个可以快速求出比其中y值大的对应的result有多少个1，比这个值小的有多少个0，我们可以利用前缀和快速求出。

实际上是用排序的方式，减少了重复多余的比较（nlogn)

整体思路就是排序，求前缀和，处理。https://blog.csdn.net/weixin_42989041/article/details/111992957?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=f3543f0f-a867-446c-a79c-6b9ea743927a&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

#include<bits/stdc++.h>
//https://blog.csdn.net/qq_43464088/article/details/112080044?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=32afdb13-d8ce-4039-89d2-b81bb3ce25d7&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control
//大佬思路真真牛逼
using namespace std;
const int N=1e5+5;//就不能双重循环了
int n,Max=0,res;
int sum[N]={0};
set<int>st;//集合set存储可选阈值/set会随着元素的插入自动去重，以及自动排序，非常适合这道题）
pair<int,int>pr[N];//pair是将2个数据组合成一组数据，当需要这样的需求时就可以使用pair/实现是一个结构体
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        int a,b;
        cin>>a>>b;
        pr[i]=make_pair(a,b);//!!
    }
    sort(pr+1,pr+n+1);//1.先排序
    for(int i=1;i<=n;i++)
        sum[i] =sum[i-1]+ pr[i].second;//2.求挂科情况前缀和【+1 +0】
    for(int i=1;i<=n;i++)
    {
        int a=pr[i].first;//选取阈值
        if(st.count(a)) continue;//set去重【相同的阈值 他们的预测正确次数肯定是一样的 对就是对]
        st.insert(a);
        int yuce1 = sum[n]-sum[i-1];//大于等于阈值时，应统计预测结果中为1的个数
        int yuce0 = i-1-sum[i-1];//小与阈值时，应统计预测结果中为0的个数
        int yuce = yuce1+ yuce0;//合计预测正确次数 【这三步不理解拿稿纸】
        if(yuce >= Max) {
            Max=yuce;
            res=a;
        }
    }
    cout<<res;
    return 0;
}
/*为什么要用前缀和：在第一次计算完cnt(预测正确的个数)之后，遍历到剩余的可选阈值时，
只需要关注前一个可选阈值与当前遍历到的可选阈值之间的数，计算这些数被预测正确的个数的变化。
除此之外的数，要么小于前一个阈值，要么大于等于当前阈值，所以预测结果是不会变的！
就是说轮到下一个阈值i时 比i-1小的情况i-1没有计算错 比i大的情况i-1没有计算错 所以只着重关心二者之间就可以*/

关于pair: https://blog.csdn.net/lwgkzl/article/details/84202383?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=418fa13d-18aa-4d9c-ad63-aad831593ff4&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

关于set: https://blog.csdn.net/baidu_33310451/article/details/81944917

20151202 消除类游戏

如果你觉得第二题没思路 那就是你想复杂了

首先“当一行或一列上有连续”斜着连续三个不能消除

自己在底下画方格的时候忧愁一点横着竖着消了万一右边还有相同的/斜角上方有足够两个该怎么办哪

不用担心啊双重for循环会把每个角考虑到并且发现一例标记一例在后一个点的基础上足够连起来

still这个大佬：https://blog.csdn.net/tigerisland45/article/details/54565428

看代码就立马能懂啦很简单的

#include<bits/stdc++.h>
using namespace std;
int myabs(int x){ //自己弄的求绝对值函数
   return (x>=0)?x:-x;
}
int main(){

   int m,n;
   cin>>n>>m;//输入行数和列数
   int grid[n][m];
   for(int i=0;i<n;i++){
    for(int j=0;j<m;j++){
        cin>>grid[i][j];
    }
   }

   //进行行标记 （可以消除(并且若还没标记还是1~9)则置为负）
   //拿绝对值去问 这就也包含某点之前已经被标记的情况
   for(int i=0;i<n;i++){
    for(int j=0;j<m-2;j++){//为啥是m-2 卡边界嘛 一行从最左开始不能到最右才停
        if(myabs(grid[i][j])==myabs(grid[i][j+1])&&myabs(grid[i][j+1])==myabs(grid[i][j+2])){
            if(myabs(grid[i][j]>0)){
               grid[i][j] = -grid[i][j];//取负值
            }
            if(myabs(grid[i][j+1]>0)){
               grid[i][j+1] = -grid[i][j+1];
            }
            if(myabs(grid[i][j+2]>0)){
               grid[i][j+2] = -grid[i][j+2];
            }

        }
    }
   }
   //进行列标记
   for(int i=0;i<n-2;i++){
    for(int j=0;j<m;j++){
        if(myabs(grid[i][j])==myabs(grid[i+1][j])&&myabs(grid[i+1][j])==myabs(grid[i+2][j])){
            if(myabs(grid[i][j]>0)){
               grid[i][j] = -grid[i][j];//取负值
            }
            if(myabs(grid[i+1][j]>0)){
               grid[i+1][j] = -grid[i+1][j];
            }
            if(myabs(grid[i+2][j]>0)){
               grid[i+2][j] = -grid[i+2][j];
            }

        }
    }
   }
   //如若为负数 赋值为0输出
   for(int i=0;i<n;i++){
    for(int j=0;j<m;j++){
        if(grid[i][j]<0){
            grid[i][j]=0;
        }
        cout<<grid[i][j]<<" ";
    }cout<<endl;
   }


   return 0;
}

 20150901 数列分段

#include<bits/stdc++.h>
using namespace std;
int main(){

   int n;
   cin>>n;
   int arrays[n];
   int dus = 0;
   for(int i=0;i<n;i++){
    cin>>arrays[i];
   }
   for(int i=1;i<n;i++){
    if(arrays[i]!=arrays[i-1]){ //原理 看i和i-1是否相等 不等i-1算一段
        //cout<<i<<endl;
        dus++;
    }
   }
//   if(arrays[n-1]!=arrays[n-2]){
//        dus++;
//   } 真正是不需要这个if判断的 无论如何都得++ eg:0000:1 112233:3
   cout<<++dus<<endl;//为了简化写到最后输出那了 先++再输出

   return 0;
}

20150902 日期计算 很简单的 只是感觉我写的跟老奶奶的裹脚布一样 dalao：https://blog.csdn.net/tigerisland45/article/details/54769447

#include<bits/stdc++.h>
using namespace std;
int mou[12]={31,28,31,30,31,30,31,31,30,31,30,31};

int main(){

     int y,d;
     cin>>y>>d;//给定年份和整数
     bool isr=false;
     if((y%400==0)||(y%4==0&&y%100!=0)){
            isr = true;//是闰年
     }
    //不同年份的月份前缀和
    int bedays1[12]={0};
    int bedays2[12]={0};
    for(int i=0;i<12;i++){
        if(i==1){
            if(isr){
                bedays2[1]+=1;
            }
        }
        if(i==0){
            bedays1[0]=mou[0];
            bedays2[0]=mou[0];
        }else{
            bedays1[i]=mou[i]+bedays1[i-1]+bedays1[i];
            if(isr){bedays2[i]=bedays1[i]+1;}
            else{
                bedays2[i]=bedays1[i];
            }
        }

    }
//    for(int i=0;i<12;i++){
//        cout<<bedays1[i]<<" ";
//    }cout<<endl;
//    for(int i=0;i<12;i++){
//        cout<<bedays2[i]<<" ";
//    }cout<<endl;

      if(isr){
        for(int i=0;i<12;i++){
            if(d<=31){//就在1月
               cout<<"1"<<endl;
               cout<<d<<endl;
               break;
            }else{
              if(d>bedays2[i]&&d<=bedays2[i+1]){
                cout<<i+2<<endl;
                cout<<d-bedays2[i]<<endl;
              }
            }
        }
      }else{
          for(int i=0;i<12;i++){
            if(d<=31){//就在1月
               cout<<"1"<<endl;
               cout<<d<<endl;
               break;
            }else{
              if(d>bedays1[i]&&d<=bedays1[i+1]){
                cout<<i+2<<endl;
                cout<<d-bedays1[i]<<endl;
              }
            }
        }

      }

     return 0;
}

20150302数字排序

MAP:https://www.cnblogs.com/fnlingnzb-learner/p/5833051.html 很不错 仔细看

运算符重载这块 不会的话就可以选择不用优先队列 map存储好之后然后再排序

https://blog.csdn.net/Kyrie6c/article/details/104979813 可以看看 重点是数组如何进行降序排列

好像也不行 就用priority_queue吧

#include<bits/stdc++.h>
using namespace std;
struct node{
    int key;
    int times;

    bool operator < (const node& n) const {//这：运算符重载
        if(times == n.times)//次数相同时 key值高的优先
            return key > n.key;
        else
            return times < n.times;//否则次数高优先
    }
};
int main(){
      priority_queue<node> q;
      map<int,int>m;
      int n,v;cin>>n;
      for(int i=0;i<n;i++){
        cin>>v;
        m[v]++;//用map 数据相应存储完毕
      }

      node keyval;
      map<int, int>::iterator iter;
      for(iter=m.begin();iter!=m.end();iter++){
        keyval.key = iter->first;
        keyval.times = iter->second;
        q.push(keyval);
      }

      //输出结果
      while(!q.empty()){
        keyval = q.top();
        q.pop();
        cout<<keyval.key<<" "<<keyval.times<<endl;
      }
       return 0;
}
/*
priority_queue<node> q;：//定义了一个元素有序排列的队列。默认队列头部的元素优先级最高。
模板申明带3个参数：priority_queue<Type, Container, Functional>，其中Type为数据类型Container为保存数据的容器Functional为元素比较方式。
STL里面默认用的是vector。比较方式默认用operator<，所以如果把后面2个参数缺省的话，优先队列就是大顶堆（降序），队头元素最大
q.push(keyval);//这通常会包含一个排序操作 这就用到了结构体里那个函数 决定了容器中最大的元素会排在队列前面
*/

 20141201门禁系统 用map一分钟就出来了啊so easy

#include<bits/stdc++.h>
using namespace std;
int main(){


     map<int,int>come;
     int n,v;
     cin>>n;
     for(int i=0;i<n;i++){
        cin>>v;
        come[v]++;
        cout<<come[v]<<" ";
     }
     return 0;
}

20141202 Z字型扫描 

真是个有意思的题目 把我的信心打击的七零八落

矩阵大小定了之后，每一步都是固定的    Z字型就能走四个方法：向右向下向左下向右上 

还是大佬的：https://blog.csdn.net/tigerisland45/article/details/54773635 讲了两个方法

方法一就是把所有当前可能在的位置以及方向列出来决定下一个方向(就8种) 找到方向后就往这走 while循环就可以了

另一种表述：https://blog.csdn.net/srg1011/article/details/61627420

方法二就是找到规律了：判断当前行是奇数行还是偶数行（x/2==x&1）奇数行左下偶数行右上 中间那段坐标调整要根据N来，比如N是奇数，做完上三角形后y就会多++一次(x没动/先输出再加) 这里减去就行。

https://www.cnblogs.com/syq816/p/12389920.html 详细的解析

#include<bits/stdc++.h>
using namespace std;

const int right1=0;
const int down=1;
const int leftdown=2;
const int upright=3;

struct {
    int row;//行
    int col;
}direction[4]={{0,1},{1,0},{1,-1},{-1,1}};

const int N=500;
int a[N][N];


int main(){

     int n;
     cin>>n;
     for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cin>>a[i][j];
        }
     }

     //输出
     int row=0,col=0,next=right1;//初始状态 肯定往右走嘛
     cout<<a[row][col];
     while(row!=n-1 || col!=n-1){//==row+col<=2n-1
         row+=direction[next].row;
         col+=direction[next].col;//！！！
         cout<<" "<<a[row][col];

         //判断下一步d方向  if的next是指当前方向
         if(next==right1&&row==0){//当前方向向右 并且在第一行
            next=leftdown;//左下
         }
         else if(next==right1&&row==n-1){//当前方向向右 并且在最后一行
            next=upright;//右上
         }
         else if(next==down&&col==0){//当前方向向下 并且在第一列
            next=upright;//右上
         }
         else if(next==down&&col==n-1){//当前方向向下  并且在最后一列
            next=leftdown;//左下
         }
         else if(next==leftdown&&row==n-1){//当前方向左下 并且在最后一行
            next=right1;//向右
         }
         else if(next==leftdown&&col==0){//当前方向左下 并且在第一列
            next=down;//向下
         }
         else if(next==upright&&col==n-1){//当前方向左上 并且在最后一列
            next=down;//向下
         }
         else if(next==upright&&row==0){//当前方向左上 并且在第一行
            next=right1;//向右
         }

     }
     cout<<endl;

     return 0;
}

 20140902 画图 easy

#include<bits/stdc++.h>
using namespace std;
int main(){


   int n;cin>>n;
   int a1,a2,a3,a4,i=0;
   int color[101][101]={0};
   int sum=0;
   while(i<n){
    cin>>a1>>a2>>a3>>a4;
    for(int j=a1;j<a3;j++){
        for(int k=a2;k<a4;k++){
            if(color[j][k]!=0){//有人来过了 无所谓了那就 随意处理
                color[j][k]=-color[j][k];
            }else if(color[j][k]==0){ //证明还没有人来过
               color[j][k]= i+1;
               sum++;
            }
        }
    }
    i++;
//    for(int j=a1;j<a3;j++){
//        for(int k=a2;k<a4;k++){
//            cout<<color[j][k]<<" ";
//        }cout<<endl;
//    }cout<<endl; //输出判断

   }cout<<sum<<endl;
   return 0;
}

 20131201 出现次数最多的数  重点是map的迭代！= 以及map的默认升序就解决很多问题了

#include<bits/stdc++.h>
using namespace std;
int main(){//重点是map默认对关键字按升序排列


    int n,v;
    cin>>n;
    int max2=0;
    int min1=0;
    map<int,int>m;
    for(int i=0;i<n;i++){
        cin>>v;
        m[v]++;
    }//map已经按照first由小到大排好顺序了
    //迭代就好
    map<int,int>::iterator iter;
    for(iter=m.begin();iter!=m.end();iter++){
        if(iter->second>max2){
            max2 = iter->second;
            min1 = iter->first;
        }
    }
    cout<<min1<<endl;


    return 0;
}

 20140303 窗口 

map+结构体
1.key是结构体
限制：map它是内部有序的/得重新定个规则 重载operator<运算符函数(map也有无序的unordered_map
https://www.cnblogs.com/Hwangzhiyoung/p/9566127.html

2.value是结构体
https://blog.csdn.net/wintersense/article/details/40475299
it->first it->second.alertUp

下面想的代码是错误的 因为虽然map可以由小到大排序 但是key值无法更改 原本想谁在最上谁设置0的/不行

#include<bits/stdc++.h>
using namespace std;
struct nodes{
    int a1;
    int a2;
    int a3;
    int a4;
    int former;
};
int main(){


     int N,M;
     cin>>N>>M;
     map<int,nodes> m;
     int zone[2560][1440];
     for(int i=N;i>0;i--){//数越小窗口位置越高
        cin>>m[i].a1>>m[i].a2>>m[i].a3>>m[i].a4;
        for(int j=m[i].a1;j<m[i].a3;j++){
            for(int k=m[i].a2;k<m[i].a4;k++){
                 zone[j][k]=i;
            }
        }
        m[i].former = i;
     }//map由小到大排序
     int b1,b2;
     map<int,nodes>::iterator iter;
     for(iter=m.begin();iter!=m.end();iter++){
        if(iter->second.a1<=b1 && b1<=iter->second.a3 && iter->second.a2<=b2 && b2<=iter->second.a4){
            cout<<iter->first<<endl;
           // iter->first = 0;//对于迭代器来说，可以修改实值，而不能修改key。
        }else if(iter->first==0){
           // iter->first = iter->second.former;
        }
     }
     return 0;
}

 正确的代码  easy啊唉效率好低

#include<bits/stdc++.h>
using namespace std;
//https://blog.csdn.net/tigerisland45/article/details/54782238
//和他下方的“水题”那个 看看写法
//就是想的那么做
struct nodes{
     int a1;
     int a2;
     int a3;
     int a4;
     int number;
};
int main(){

    int n,m;
    cin>>n>>m;
    nodes node[n+1] ;
    for(int i=n;i>0;i--){
        cin>>node[i].a1>>node[i].a2>>node[i].a3>>node[i].a4;
        node[i].number = n-i+1;//!!
    }
    int b1,b2;
    nodes temp;
    bool findy = false;
    while(m--){
        cin>>b1>>b2;
        findy = false;
        for(int i=1;i<=n;i++){
           if(node[i].a1<=b1 && node[i].a3>=b1 && node[i].a2<=b2 && node[i].a4>=b2){//命中
                cout<<node[i].number<<endl;
                //开始移动
                temp = node[i];
                for(int j=i;j>1;j--){//!! 1
                    node[j] = node[j-1];
                }
                node[1] = temp;//!! 1
                findy = true;
                break;//!!
           }
        }
        if(!findy){
            cout<<"IGNORED"<<endl;
        }
    }



}

 20131202  easy ISBN号码

#include<bits/stdc++.h>
using namespace std;
int main(){

     int sum=0;
     char v;
     char save[13];
     int truei=0;
     for(int i=0;i<13;i++){
        cin>>v;save[i]=v;
        if(i==1||i==5||i==11||i==12){
            //cout<<endl;//占位而已
        }else{
          sum+=(v-'0')*(++truei);
        }
     }
     if((sum%11==(save[12]-'0'))||(sum%11==10&&save[12]=='X')){
        cout<<"Right"<<endl;
     }else{
       for(int i=0;i<12;i++){
        cout<<save[i];
       }
       if(sum%11==10){
        cout<<"X"<<endl;
       }else{
         cout<<sum%11<<endl;
       }
     }

    return 0;
}