Countdown

最新推荐文章于 2019-10-24 19:28:18 发布
最新推荐文章于 2019-10-24 19:28:18 发布
阅读量633 收藏
点赞数
分类专栏： acm训练 UVALive
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzh823046544/article/details/52440278
版权

Countdown

这里写图片描述
这里写图片描述
.
.
题意：给出6个数，通过+、-、*、/、四种操作，每个数只能用一次，问怎么算能得到一个尽量接近target的数（target给定），然后按题目要求输出。
.
.
解法：这题直接暴力死做不会超时，用map记录数字使用情况以及得出来的值，保存一下是从那两个状态转移过来就好了。.
.
.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <map>
#include <algorithm>
#include <vector>
using namespace std;

struct Node {
    int val, state;
    Node() {}
    Node(int _v, int _s):val(_v), state(_s) {}
    void operator=(Node &other) {
        val = other.val;
        state = other.state;
    }
    bool operator<(const Node &other) const {
        if (val < other.val) return true;
        if (val > other.val) return false;
        if (state < other.state) return true;
        return false;
    }
    bool operator==(const Node &other) const {
        if (val == other.val && state == other.state) return true;
        return false;
    }
    bool operator!=(const Node &other) const {
        if (*this == other) return false;
        return true;
    }
};

struct Pre {
    Node p1, p2;    
};

map<Node, Pre> store;
vector<Node> f[1<<6];
Pre d[400000];
int val[400000];
Node ans;
int tot, x, y, tar, a[10], sum, n, m;

int main() {
    freopen("j.in","r",stdin);
    int tt;
    Node start(0, 0);
    scanf("%d", &tt);
    for (int cases = 1; cases <= tt; cases++) {
        if (cases > 1) printf("\n");
        store.clear();
        for (int i = 0; i < 1<<6; i++) f[i].clear();
        for (int i = 1; i <= 6; i++) scanf("%d", &a[i]);
        scanf("%d", &tar);
        ans.val = 1000000;
        for (int i = 1; i <= 6; i++) {
            Node temp(a[i], 1<<(i-1));
            f[1<<(i-1)].push_back(temp);
            store[temp].p1 = start;
            store[temp].p2 = start;
            if (abs(tar-a[i]) < abs(tar-ans.val)) {
                ans.val = a[i];
                ans.state = 1<<(i-1);
            }
        }
        for (int i = 1; i <= (1<<6)-1; i++) {
            for (int jj = 1; jj <= (1<<6)-1;  jj++) {
                for (int kk = jj+1; kk <= (1<<6)-1; kk++)
                    if (((jj|kk) == i) && ((jj&kk) == 0)) {
                    n = f[jj].size();
                    m = f[kk].size();

                    for (int j = 0; j < n; j++)
                        for (int k = 0; k < m; k++) {
                            Node temp;
                            temp.state = i;
                            //  +
                            temp.val = f[jj][j].val+f[kk][k].val;
                            if (!store.count(temp)) {
                                f[i].push_back(temp);
                                if (abs(tar-temp.val) < abs(tar-ans.val)) ans = temp;
                                store[temp].p1 = f[jj][j];
                                store[temp].p2 = f[kk][k];
                            }

                            //  *
                            temp.val = f[jj][j].val*f[kk][k].val;
                            if (!store.count(temp)) {
                                f[i].push_back(temp);
                                if (abs(tar-temp.val) < abs(tar-ans.val)) ans = temp;
                                store[temp].p1 = f[jj][j];
                                store[temp].p2 = f[kk][k];
                            }

                            //  -
                            temp.val = f[jj][j].val-f[kk][k].val;
                            if (temp.val > 0 && !store.count(temp)) {
                                f[i].push_back(temp);
                                if (abs(tar-temp.val) < abs(tar-ans.val)) ans = temp;
                                store[temp].p1 = f[jj][j];
                                store[temp].p2 = f[kk][k];
                            }

                            temp.val = -f[jj][j].val+f[kk][k].val;
                            if (temp.val > 0 && !store.count(temp)) {
                                f[i].push_back(temp);
                                if (abs(tar-temp.val) < abs(tar-ans.val)) ans = temp;
                                store[temp].p1 = f[jj][j];
                                store[temp].p2 = f[kk][k];
                            }

                            //  /
                            if (f[kk][k].val != 0 && f[jj][j].val%f[kk][k].val == 0) {
                                temp.val = f[jj][j].val/f[kk][k].val;
                                if (!store.count(temp)) {
                                    f[i].push_back(temp);
                                    if (abs(tar-temp.val) < abs(tar-ans.val)) ans = temp;
                                    store[temp].p1 = f[jj][j];
                                    store[temp].p2 = f[kk][k];
                                }
                            }

                            if (f[jj][j].val != 0 && f[kk][k].val%f[jj][j].val == 0) {
                                temp.val = f[kk][k].val/f[jj][j].val;
                                if (!store.count(temp)) {
                                    f[i].push_back(temp);
                                    if (abs(tar-temp.val) < abs(tar-ans.val)) ans = temp;
                                    store[temp].p1 = f[jj][j];
                                    store[temp].p2 = f[kk][k];
                                }
                            }

                        }
                }
            }
        }

        tot = 0;
        if (store[ans].p1 != start || store[ans].p2 != start) {
            tot++;
            d[tot] = store[ans];
            val[tot] = ans.val;
            for (int i = 1; i <= tot; i++) {
                if (store[d[i].p1].p1 != start) {
                    tot++;
                    d[tot] = store[d[i].p1];
                    val[tot] = d[i].p1.val;
                }
                if (store[d[i].p2].p1 != start) {
                    tot++;
                    d[tot] = store[d[i].p2];
                    val[tot] = d[i].p2.val;
                }
            }
        }
        printf("Target: %d\n", tar);
        for (int i = tot; i >= 1; i--) {
            //  +
            if (d[i].p1.val + d[i].p2.val == val[i]) {
                printf("%d + %d = %d\n", d[i].p1.val, d[i].p2.val, val[i]);
                continue;
            }

            //  -
            if (d[i].p1.val - d[i].p2.val == val[i]) {
                printf("%d - %d = %d\n", d[i].p1.val, d[i].p2.val, val[i]);
                continue;
            }
            if (d[i].p2.val - d[i].p1.val == val[i]) {
                printf("%d - %d = %d\n", d[i].p2.val, d[i].p1.val, val[i]);
                continue;
            }

            //  *
            if (d[i].p1.val * d[i].p2.val == val[i]) {
                printf("%d * %d = %d\n", d[i].p1.val, d[i].p2.val, val[i]);
                continue;
            }

            //  /
            if (d[i].p2.val != 0 && d[i].p1.val / d[i].p2.val == val[i]) {
                printf("%d / %d = %d\n", d[i].p1.val, d[i].p2.val, val[i]);
                continue;
            }
            if (d[i].p1.val != 0 && d[i].p2.val / d[i].p1.val == val[i]) {
                printf("%d / %d = %d\n", d[i].p2.val, d[i].p1.val, val[i]);
                continue;
            }
        }
        printf("Best approx: %d\n", ans.val);

    }
}
lzh823046544
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
countdown
03-29
countdown
实现一个简易的Python版CountDownLatch
mark's technic world
01-11 1627
''' Created on 2017-1-11 @author: admin ''' from threading import Condition, Thread import time class CountDownLatch: def __init__(self,count): self.count=count self.condition=Co
CountDown
SeptemberTan的博客
10-24 354
private Coroutine a; // Use this for initialization void Start () { IEnumerator CountDown = Write(1); a = StartCoroutine(CountDown); } // Update is called once per frame void Update () { ...
基于python实现CountdownLatch机制
benzyh的专栏
08-11 2292
from threading import Condition class CountDownLatch: def __init__(self,count): self.count = count self.condition = Condition() def await(self): try: sel
tools: countdown
hunter
09-02 151
Best Countdown Timer App for Linux - Computing for Geeks
CountDownLatch使用
tylcheck的博客
08-21 1021
CountDownLatch类的使用，CountDownLatch是一个工具类，运行主线程开启子线程的时候，子线程还没有结束的时候，主线程可以一直等待，直到初始化的现成的计数器count为0,主线程就可以不用等待继续执行了。 注意： count只能在实例化CountDownLatch类的时候初始化，没有其他的办法count注入值。 countDown方法，当前线程调用此方法，则计数在实例...
并发-同步工具类CountDownLatch
FLY_WU
05-29 158
CountDownLatch是一个同步工具，它允许一个或者多个线程一直等待，直到其他线程的操作执行完成后在执行。CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器的值达到0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。1. 源码分析：  源码位于rt.java 中的java....
An Easy Physics Problem
lzh的博客
09-12 672
An Easy Physics Problem . . 题意：平面上一个点与圆，点延一个方向前进，问能否达到另外一个点。 . . 解法：分两种，1是相撞，2是相离或相切。对于第二种直接求解就好了，而第一种注意一下精度，考虑点出现在相撞前的地方等就好了。 . . 队友代码#include <cstdio> #include <iostream> #include <cmath> #i
Islands
lzh的博客
09-04 428
Islands . . 这是道水题，每一个联通块是一个小岛，求问小岛边长与面积比的最大值和最小值。 直接在图上dfs就好了，记录每个小岛面积以及周长（即dfs下一步会到达水域位置）。 . .#include <stdio.h> #include <stdlib.h> #include <string.h> #include <string>const int maxn = 500; ch
Digits Count
lzh的博客
09-11 388
Digits Count. . . 题意：问A~B之间，每个数字出现的多少次. . . 解法：水题，直接计算每一位上出现的 0~9 可能的出现次数， 就是前面乘上后面的（10^k形式），然后统计即可。 . . 队友代码#include <cstdio> #include <cstring> #include <algorithm> using namespace std; int
Beehives
lzh的博客
09-05 385
Beehives . . 题意：给出一个无向图，求最短的环 . . 解法：由于点数只有500， 对于每一个点做一次bfs就好了，只要搜到之前更新过的点那么就是一个环了，bfs保证了最短。 . .#include <iostream> #include <stdio.h> #include <stdlib.h> #include <vector> #include <algorithm
Grass is Green
lzh的博客
09-04 351
Grass is Green . . 题意：水题，给定每个人的钱、买地的单位价格，买草的单位价格，买篱笆的单位价格，问买地面积比第一位大的有多少人。 解法：直接解二元一次方程组，计算每个人能买的最大变长，然后判断即可。 . .#include <iostream> #include <stdio.h> #include <stdlib.h> #include <algorithm> #i
Friendship of Frog
lzh的博客
09-12 319
Friendship of Frog . .求最靠近的两个相同字母 n^2暴力就好了#include <iostream> #include <stdio.h> #include <stdlib.h> using namespace std;string s; int n, m, ans;int main() { cin >> n; for (int cases = 1; ca
LCM Walk
lzh的博客
09-12 301
LCM Walk . . 假设 x = p * k , y = q * k ( k = gcd(x,y) ) 那么 z = p*q*k. 下一步会跳到( k * p * (1+q) , q * k ) 或者 ( p * k , k * q * ( 1 + p ) )，然后发现他们的gcd值并没有改变，所以推出无论跳多少步，gcd值永远不会改变。所以除去gcd的值后，每次都是 较大
Space Junk
lzh的博客
09-03 296
Space Junk . . 题意：给出两个球三位位置，半径以及速度向量，问什么时候能相撞。 . . 解法：很明显这是一个不等式方程： (X1+VX1∗t−X2−VX2∗t)2+(Y1+VY1∗t−Y2−VY2∗t)2+(Z1+VZ1∗t−Z2−VZ2∗t)2−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Bundles of Joy
lzh的博客
09-03 295
Bundles of Joy . . 题意：给定m个包裹，n个蛋糕，每个包裹包含一些蛋糕以及所需要的费用，保证包裹之间蛋糕集合只会出现包含或者相离的关系，问买完所有蛋糕的最小花费（蛋糕不能买重复）。 . . 解法：类似拓扑序。因为只有包含或者无关，所以对于每一个包裹，看能否被前面所有被他包含的包裹的花费更新，如果可以就更新，最后求出全集的花费。 . .#include <iost
Kingdom of Black and White
lzh的博客
09-12 271
Kingdom of Black and White . . 给定一个01串，相邻相同的数字为一块，串的权值定义为所有块长度的平方和。求最多改变一个值使得权值最大。 . . 解法：首先对于一个连续串，不会改变中间的值，只会更改两头的值，所以先算好原来所有块的长度以及权值，然后一个个更改判断是否会变大就好了，注意一下只有长度为1的块就好了。 . .#include <iostream>
$CountDown
最新发布
09-14
$CountDown是一个用于设置倒计时的方法。在引用中，CountDown-jQuery插件提供了一个名为CountDown的方法，可以通过以下方式启动倒计时： ```javascript $('#countdown_dashboard').countDown({ targetOffset: { '...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值