博客

int getgrade(int a, int b, char c, char d, int e)
{
        int n = 0;
        if(a > 80 && e > 0){
                n += 8000;
        }
        if(a > 85 && b > 80){
                n += 4000;
        }
        if(a > 90){
                n += 2000;
        }
        if(a > 85 && d == ‘Y’){
                n += 1000;
        }
        if(b > 80 && c == ‘Y’){
                n += 850;
        }
        return n;
}

int main(void)
{
        struct pep t, max;
        int a, b, e;
        char c, d;
        int n, i;
        int ans = 0;
        max.grade = 0;
        scanf("%d\n", &n);
        for(i = 0; i < n; i++){
                scanf("%s %d %d %c %c %d\n", t.name, &a, &b, &c, &d, &e);
                t.grade = getgrade(a, b, c, d, e);
                ans += t.grade;
                if(t.grade > max.grade){
                        max = t;
                }
        }
        printf("%s\n%d\n%d\n", max.name, max.grade, ans);
        return 0;
}

int main(void)
{
        int i, j, k, c, l;
        int m, n, t, s;
        scanf("%d%d", &m, &n);
        for(i = 0; i < m n; i++){
                scanf("%d", &order[i]);
                order[i]–;
        }
        for(i = 0; i < n; i++){
                for(j = 0; j < m; j++){
                        //把n写成了m         
                        scanf("%d", &mch[i][j]);
                        mch[i][j]–;
                }
        }
        for(i = 0; i < n; i++){
                for(j = 0; j < m; j++){
                        //把n写成了m         
                        scanf("%d", &time[i][j]);
                }
        }
        for(i = 0; i < m n; i++){
                t = order[i];
                s = count[t]++;
                k = used[t];
                while(1){
                        while(cpu[mch[t][s]][k]){
                                k++;
                        }
                        c = 0;
                        while(cpu[mch[t][s]][k + c] == 0 && c < time[t][s]){
                                c++;
                        }
                        if(c == time[t][s]){
                                c = 0;
                                while(c < time[t][s]){
                                        cpu[mch[t][s]][k + c] = 1;
                                        c++;
                                }
                                break;
                        }
                        k += c;
                }
                used[t] = k + time[t][s];
                ans = max(ans, used[t]);
        }
        printf("%d\n", ans);
        return 0;
}

int main(void)
{
        int m, n;
        int i, j, k;
        int a, b, c;
        struct thing t;
        scanf("%d%d", &m, &n);
        for(i = 0; i < n; i++){
                scanf("%d%d%d", &a, &b, &c);
                if(c == 0){
                        num[len++] = i;
                        buy[i].priece = a b;
                        buy[i].cost = a;
                }else{
                        t = &buy[c – 1];
                        t->sub[t->len].priece = a * b;
                        t->sub[t->len].cost = a;
                        t->len++;
                }
        }
        for(i = 0; i < len; i++){
                t = &buy[num[i]];
                for(j = m; j >= t->cost; j–){
                        f[j] = max(f[j], f[j – t->cost] + t->priece);
                        for(k = 0; k < t->len; k++){
                                if(j – t->cost – t->sub[k].cost >= 0){
                                        f[j] = max(f[j], f[j – t->cost – t->sub[k].cost] + t->priece + t->sub[k].priece);
                                }
                        }
                        if(t->len == 2 && (j – t->cost – t->sub[0].cost – t->sub[1].cost >= 0)){
                                f[j] = max(f[j], f[j – t->cost – t->sub[0].cost – t->sub[1].cost] + t->priece + t->sub[0].priece + t->sub[1].priece);
                                                //把减法写成了加法,, 
                        }
                }
        }
        printf("%d\n", f[m]);
        return 0;
}

void deal(int a, int b)
{
        int i;
        unsigned max = 0, t;
        for(i = 1; i < b; i++){
                t = map[a] map[a + i] map[a + b]
                                        //这里的a+b写成了a + i + 1
                        + f[a][i] + f[(a + i) % n][b – i];
                if(t > max){
                        max = t;
                }
        }
        f[a][b] = max;
}

int main(void)
{
        int i, j;
        unsigned max;
//      freopen("abc.txt", "r", stdin);
        scanf("%d", &n);
        for(i = 0; i < n; i++){
                scanf("%d", &map[i]);
                map[i + n] = map[i];
        }
        for(j = 2; j <= n; j++){
                for(i = 0; i < n; i++){
                        deal(i, j);
                }
        }
        max = 0;
        for(i = 0; i < n; i++){
                if(max < f[i][n]){
                        max = f[i][n];
                }
        }
        printf("%d\n", max);
//      getch();
        return 0;
}

int ans = 10000000;

int used[300];
int prev[300];
int dist[300];
int max, loc;

void d(int i, int sum)
{
        int j;
        used[i] = 1;
        if(sum > max){
                loc = i;
                max = sum;
        }
        for(j = 0; j < n; j++){
                if(!used[j] && map[i][j]){
                        dist[j] = sum + map[i][j];
                        prev[j] = i;
                        d(j, dist[j]);
                }
        }
}

void dfs(int node)
{
        bzero(used, sizeof(used));
        bzero(prev, sizeof(prev));
        bzero(dist, sizeof(dist));
        max = 0;
        prev[node] = –1;
        d(node, 0);
}

int lis[300];
int lenth;

void find(void)
{
        int i;
        dfs(0);
        dfs(loc);
        i = loc;
        while(i != –1){
                lis[lenth++] = i;
                i = prev[i];
        }
}

int tmp[90000];

//先删除本路径, 再逐个dfs,, 再恢复路径 
void deal(int a, int b)
{
        int i, m;
        //删除本路劲 
        for(i = a; i < b; i++){
                tmp[i – a] = map[lis[i]][lis[i + 1]];
                map[lis[i]][lis[i + 1]] = 0;
                map[lis[i + 1]][lis[i]] = 0;
        }
        //获取距离本路径最远的距离
        m = 0;
        for(i = a; i <= b; i++){
                dfs(lis[i]);
                if(m < max){
                        m = max;
                }
        }
        //更新ans 
        if(ans > m){
                ans = m;
        }
        //恢复路径 
        for(i = a; i < b; i++){
                map[lis[i]][lis[i + 1]] = tmp[i – a];
                map[lis[i + 1]][lis[i]] = tmp[i – a];
        }
}

void work(void)
{
        int i, j;
        int d;
        for(i = 0; i < lenth; i++){
                //寻找尽可能长的核 
                d = map[lis[i]][lis[i + 1]];
                for(j = i + 1; j < lenth && d <= s; j++){ 
                        d += map[lis[j]][lis[j + 1]];
                }
                //获取此核的长度, 并更新ans 
                deal(i, j – 1);
        }
}

int main(void)
{
        int i;
        int a, b, c;
        scanf("%d%d", &n, &s);
        for(i = 1; i < n; i++){
                scanf("%d%d%d", &a, &b, &c);
                a–, b–;
                map[a][b] = map[b][a] = c;
        }
        //寻找半径,, 然后用lis数组记录半径的线路 
        find();
        //寻找最小的偏心距,,  用ans记录 
        work();
        printf("%d\n", ans);
        return 0;
}