学步园

A:边界不用处理，直接暴力遍历原始数组

#include<stdio.h>
#include<string.h>

char a[150] = " qwertyuiopasdfghjkl;zxcvbnm,./";

int main()
{
    char c;
    char v[150];
    while(~scanf("%c%*c", &c))
    {
        scanf("%s%*c", v);
        for(int i = 0; v[i]; i++)
        {
            for(int j = 1; a[j]; j++) 
            {
                if(a[j] == v[i])
                    if(c == 'R')
                        printf("%c", a[j-1]);
                    else if(c == 'L')
                        printf("%c", a[j+1]);
            }
        }
        printf("\n");
    }
    return 0;
}

B：二分查找下界，但其实low_bound函数直接可以完成

#include<stdio.h>
#include<string.h>

#define N 100005

int a[N];

int main()
{
    int n, m;
    while(~scanf("%d", &n))
    {
        int x;
        a[0] = 0;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &x);
            a[i] = a[i-1] + x;
        }
        scanf("%d", &m);
        while(m--)
        {
            scanf("%d", &x);
            int l = 1, r = n;
            while(l < r)
            {
                int mid = (l + r) / 2;
                if(x <= a[mid])
                    r = mid;
                else l = mid + 1;
            }
            printf("%d\n", l);
        }
    }
    return 0;
}

OTL lower_bound..

#include <cstdio>
#include <algorithm>

using namespace std;

const int kMaxN = 100000;
int n, s[kMaxN + 1];

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++ i) {
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }
    int m;
    scanf("%d", &m);
    for (int x; m --; ) {
        scanf("%d", &x);
        int p = lower_bound(s + 1, s + n + 1, x) - s;
        printf("%d\n", p);
    }
    return 0;
}

C:每个点有一个初始坐标以及一个中心轴坐标，该点可绕中心轴逆时针旋转90度，每旋转90度算一步移动。现在给你四个点，问最少需要多少步可以得到一个由这四个点旋转后的坐标（可以不旋转）构成的正方形。

一共是4*4*4*4种情况，注意的是下标从1开始的话要减回去一个1.

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

#define rep(i, n) for(int i = 1; i <= n; i++)

typedef long long LL;
struct node{
    int x, y;
    void input()
    {
        scanf("%d%d", &x, &y);
    }
    void show()
    {
        printf("x: %d y: %d\n", x, y);
    }
}p[10][10], home[5];

LL d[10];

LL dist ( const node& a , const node& b ) {  
    LL x = a.x - b.x ;  
    LL y = a.y - b.y ;  
    return x * x + y * y ;  
}  

LL solve()
{
    LL ans = 999;
    rep(i, 4)
        rep(j, 4)
            rep(k, 4)
                rep(o, 4)
                {
                    d[0] = dist ( p[1][i] , p[2][j] ) ;  
                    d[1] = dist ( p[2][j] , p[3][k] ) ;  
                    d[2] = dist ( p[3][k] , p[4][o] ) ;  
                    d[3] = dist ( p[4][o] , p[1][i] ) ;  
                    d[4] = dist ( p[1][i] , p[3][k] ) ;  
                    d[5] = dist ( p[2][j] , p[4][o] ) ;  
                    sort ( d , d + 6 ) ;  
                    if ( d[0] == 0 ) continue ;  
                    else if ( d[0] == d[1] && d[1] == d[2] && d[2] == d[3] && d[4] == 2 * d[0] && d[4] == d[5] ) 
                    {  
                        ans = ans < i + j + k + o - 4? ans : i + j + k + o - 4;
                    }  
                }
    
    return ans == 999 ? -1: ans;    
}

int main()
{
    int n;
    while(~scanf("%d", &n))
    while(n--)
    {
        rep(i, 4)
        {
            p[i][1].input();
            home[i].input();
            
            p[i][4].x = home[i].x - home[i].y + p[i][1].y ;  
            p[i][4].y = home[i].y + home[i].x - p[i][1].x ;  
              
            p[i][3].x = home[i].x + home[i].x - p[i][1].x ;  
            p[i][3].y = home[i].y + home[i].y - p[i][1].y ;  
              
            p[i][2].x = home[i].x + home[i].x - p[i][4].x ;  
            p[i][2].y = home[i].y + home[i].y - p[i][4].y ;  
            
        }
        printf("%d\n", solve());
    }
    return 0;
}