[USACO1.4] [IOI1994]时钟 The Clocks

最新推荐文章于 2024-07-18 18:43:19 发布
最新推荐文章于 2024-07-18 18:43:19 发布
阅读量725 收藏 9
点赞数 10
文章标签： 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NDCSID/article/details/140061708
版权

题目描述

考虑将如此安排在一个 3 \times 33×3 行列中的九个时钟:

|-------|   |-------|   |-------|
|       |   |       |   |   |   |
|---o   |   |---o   |   |   o   |
|       |   |       |   |       |
|-------|   |-------|   |-------|
    A           B           C

|-------|   |-------|   |-------|
|       |   |       |   |       |
|   o   |   |   o   |   |   o   |
|   |   |   |   |   |   |   |   |
|-------|   |-------|   |-------|
    D           E           F

|-------|   |-------|   |-------|
|       |   |       |   |       |
|   o   |   |   o---|   |   o   |
|   |   |   |       |   |   |   |
|-------|   |-------|   |-------|
    G           H           I

目标要找一个最小的移动顺序将所有的指针指向 1212 点。下面原表格列出了 99 种不同的旋转指针的方法，每一种方法都叫一次移动。
选择 1 \sim 91∼9 号移动方法，将会使在表格中对应的时钟的指针顺时针旋转 9090 度。

移动方法受影响的时钟
1ABDE
2ABC
3BCEF
4ADG
5BDEFH
6CFI
7DEGH
8GHI
9EFHI

例子：

9 9 12       9 12 12        9 12 12        12 12 12        12 12 12
6 6 6   5 -> 9  9  9   8 -> 9  9  9   4 -> 12  9  9   9 -> 12 12 12
6 3 6        6  6  6        9  9  9        12  9  9        12 12 12

但这可能不是正确的方法，请看下文。

输入格式

输入三行，每行三个正整数，表示一个时钟的初始时间，数字的含意和上面第一个例子一样。

输出格式

单独的一行包括一个用空格分开的将所有指针指向 1212 点的最短移动顺序的列表。

如果有多种方案，输出那种使其连接起来的数字最小的方案。（举例来说 5\ 2\ 4\ 6 < 9\ 3\ 1\ 15 2 4 6<9 3 1 1）。

输入输出样例

输入 #1复制

9 9 12
6 6 6
6 3 6

输出 #1复制

4 5 8 9

说明/提示

题目翻译来自NOCOW。

USACO Training Section 1.4

这题需要在可读性和效率之间妥协

Overview

一共只有 4^949 个状态，大概二十六万多一点，所以肯定是够用了

bfs肯定是那个bfs，关键是状态的表示，可以用一个int来表示状态，这样转移的时候比较麻烦，也可以用3*3矩阵来表示这样效率与空间开销会比较大虽然我用的就是这个

阅读了一下已有的题解，ummmmm，代码好丑不是很直观

可以联想到八数码和华容道

从数学角度来看，这9种运算是9个算子（最简单的加法运算）

心路历程探索过程

map <Matrix, int>

于是乎我的第一份代码（出于篇幅和美观这里给出关键代码，大家可以意会，完整代码附在最后面）


const int MOVES[11][MATRIX_N][MATRIX_N] = {
    {// ABDE
        {1,1,0},
        {1,1,0},
        {0,0,0}
    },{//ABC
        {1,1,1},
        {0,0,0},
        {0,0,0}
    },
    ...
};

struct Matrix{
    int s[MATRIX_N][MATRIX_N];

    Matrix(){memset(s, 0, sizeof(s));}
    int* operator [](int idx){return s[idx];}
    Matrix (const int arr[MATRIX_N][MATRIX_N]){...}
    void read(){...}
    friend Matrix operator + (Matrix &a, Matrix &b){...}
    friend Matrix operator - (Matrix &a, Matrix &b){...}
    friend bool operator < (const Matrix &a, const Matrix &b){...}
    bool is_target(){..}
    void print(){...}
} moves[11];

map <Matrix, int> vis;  // come from which move

void print_path(Matrix cur){
    if (vis[cur] == -1) return;
    Matrix pre = cur - moves[vis[cur]];
    print_path(pre);
    printf("%d", vis[cur] + 1);
    //cur.print();
    if (!cur.is_target()) putchar(' ');
}

void bfs(Matrix start){
    queue <Matrix> Q;
    vis[start] = -1;
    for (Q.push(start); !Q.empty();){
        Matrix cur = Q.front(); Q.pop();
        if (cur.is_target()) {
            print_path(cur);
            return;
        }
        for (int i = 0; i < 9; i++){
            Matrix nxt = cur + moves[i];
            if (vis[nxt]) continue;
            vis[nxt] = i;
            Q.push(nxt);
        }
    }
}

int main(){...}

自以为是最直观的一个版本，可能是python写多了吧。

只过了两个点，可能是过多的matrix导致效率降低，内存也难以控制

map <int, int>

于是乎往matrix中添加to_int()函数

struct Matrix{
	...

    int to_int(){
        int ans = 0;
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                ans = (ans * 10) + s[i][j];
        return ans;
    }
    ...
}

...

typedef pair<int, int> P;
map <int, P> vis;  // pair<pre, come from which move>

过了5个点，果然有毒，ummmm，加个氧气优化，过了

但是不甘心啊，思索一下，一共就那么点状态，出锅的大概率是map

老老实实哈希吧

其实数组长度只要30w就足够，可以整一个类似康托展开的哈希函数，直接计算出他是排号第几大的，不过，因为懒，为什么先模一个大质数呢暴力一下呢

于是乎

const int MOD = magic_number(a girls qq id);

struct Matrix{
    ...

    int to_int(){
        int ans = 0;
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                ans = (ans * 10) + s[i][j];
        return ans % MOD;
    }
    ...

} start, target, moves[11];

...

P vis[MOD];
//map <int, P> vis;  // pair<pre, come from which move>

void print_path(int cur){
    if (cur == start.to_int()) return;
    int pre = vis[cur].first;
    print_path(pre);
    printf("%d", vis[cur].second + 1);
    if (cur != target.to_int()) putchar(' ');
}
...

试了几个数字都WA了，这个时候已经想写类似康托展开的一样东西了，但是，似乎还能挣扎一下，常用Hash质数表

又试了两个数字，好了，A了。标准写法康托展开或者整个哈希冲突的处理（线性探查或者拉链都行）或者多次哈希多来几个magic_number。自己没有继续往下可能是因为折腾了挺久累了懒

STL有风险，使用需谨慎， 真香

最后bb几句Summary

可能工程代码写多了，更倾向于使用造好的轮子吧。

下面两份代码相信不需要什么注释，因为函数名与变量名都是有意义的单词或短语，读起来感觉像是写文章一般。每个函数都保持在20行以内，出锅的概率大大降低，编译样例无debug一遍过，这里不是说代码能力有多好，而是说，使用这个写法，会让自己思路更加清晰，一段时间内只关注一段逻辑，很多人代码debug不出来不是因为代码能力弱，反而是因为代码能力太强，像一个 int main完成所有的逻辑。这样的代码在自己脑子十分清晰的时候是可以码的飞起的，不过可能只有两天内的自己才能看懂，可能过了两天自己回头看的时候惊呼“我靠，什么shit”。这里大部分的代码依然是c语言中的strct其实是把其当成一个完全public的class来用了，再需求变更换写法的时候，只要专注那么几个函数就好了，非常快。稍微讲一点软件工程吧，但太“优雅”了又会导致代码过于膨胀，每个人写的时候都会有一个自己的平衡点。这里给出一个栗子，只是希望以后OI选手的代码风格不再被业界喷。希望以后看题解区的时候能如同读文章一样读大家的代码。

一不小心絮絮叨叨又写了一堆，睡觉睡觉

致谢

感谢又白、jjm、贾维斯帮忙看代码，感谢偶像派歌手的音乐陪我度过这个夜晚

see you later

Future Work

依然有优化空间，比如说bfs的队列里面填的是int然后做一个int转Matrix进行计算甚至直接对int空间进行九种运算。哈希这里是搜了一个简单的magic_number混过去了，前文提了可以使用更优雅的哈希。不写了，懒

  • 又白：只要容忍丑陋，九维的vis
  • 我：我拒绝

附录

悲伤是奢侈品我消受不起，快乐像噩梦总让人惊醒

AC版本代码


#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
const int MOD = 12255871;

const int MATRIX_N = 5;
const int MATRIX_SIZE = 3;

const int MOVES[11][MATRIX_N][MATRIX_N] = {
    {// ABDE
        {1,1,0},
        {1,1,0},
        {0,0,0}
    },{//ABC
        {1,1,1},
        {0,0,0},
        {0,0,0}
    },{//BCEF
        {0,1,1},
        {0,1,1},
        {0,0,0}
    },{//ADG
        {1,0,0},
        {1,0,0},
        {1,0,0}
    },{//BDEFH
        {0,1,0},
        {1,1,1},
        {0,1,0}
    },{//CFI
        {0,0,1},
        {0,0,1},
        {0,0,1}
    },{//DEGH
        {0,0,0},
        {1,1,0},
        {1,1,0}
    },{//GHI
        {0,0,0},
        {0,0,0},
        {1,1,1}
    },{//EFHI
        {0,0,0},
        {0,1,1},
        {0,1,1}
    }
};

struct Matrix{
    int s[MATRIX_N][MATRIX_N];

    Matrix(){memset(s, 0, sizeof(s));}
    int* operator [](int idx){return s[idx];}
    Matrix (const int arr[MATRIX_N][MATRIX_N]){
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                s[i][j] = arr[i][j] * 3;
    }
    void read(){
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++) {
                scanf("%d", &s[i][j]);
                s[i][j] %= 12;
            }
    }

    friend Matrix operator + (Matrix &a, Matrix &b){
        Matrix c;
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                c[i][j] = (a[i][j] + b[i][j]) % 12;
        return c;
    }

    int to_int(){
        int ans = 0;
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                ans = (ans * 10) + s[i][j];
        return ans % MOD;
    }

    void print(){
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                printf("%d%c", s[i][j], j==MATRIX_SIZE-1?' ':' ');
        puts("");
    }
} start, target, moves[11];

P vis[MOD];
//map <int, P> vis;  // pair<pre, come from which move>

void print_path(int cur){
    if (cur == start.to_int()) return;
    int pre = vis[cur].first;
    print_path(pre);
    printf("%d", vis[cur].second + 1);
    if (cur != target.to_int()) putchar(' ');
}

int bfs(Matrix start){
    queue <Matrix> Q;
    memset(vis, 0, sizeof vis);
    vis[start.to_int()] = P(-1, -1);
    for (Q.push(start); !Q.empty();){
        Matrix cur = Q.front(); Q.pop();
        if (cur.to_int() == target.to_int()) return cur.to_int();
        for (int i = 0; i < 9; i++){
            Matrix nxt = cur + moves[i];
            if (vis[nxt.to_int()] != P(0, 0)) continue;
            //if (vis.find(nxt.to_int()) != vis.end()) continue;
            vis[nxt.to_int()] = P(cur.to_int(), i);
            Q.push(nxt);
        }
    }
}

int main(){
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    for (int i = 0; i < 9; i++){
        moves[i] = Matrix(MOVES[i]);
    }
    start.read();
    int ans = bfs(start);
    print_path(ans);
    return 0;
}

第一版代码}（可能还有小坑）

反正只能过两个点，who cares

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

const int MATRIX_N = 5;
const int MATRIX_SIZE = 3;

const int MOVES[11][MATRIX_N][MATRIX_N] = {
    {// ABDE
        {1,1,0},
        {1,1,0},
        {0,0,0}
    },{//ABC
        {1,1,1},
        {0,0,0},
        {0,0,0}
    },{//BCEF
        {0,1,1},
        {0,1,1},
        {0,0,0}
    },{//ADG
        {1,0,0},
        {1,0,0},
        {1,0,0}
    },{//BDEFH
        {0,1,0},
        {1,1,1},
        {0,1,0}
    },{//CFI
        {0,0,1},
        {0,0,1},
        {0,0,1}
    },{//DEGH
        {0,0,0},
        {1,1,0},
        {1,1,0}
    },{//GHI
        {0,0,0},
        {0,0,0},
        {1,1,1}
    },{//EFHI
        {0,0,0},
        {0,1,1},
        {0,1,1}
    }
};

struct Matrix{
    int s[MATRIX_N][MATRIX_N];

    Matrix(){memset(s, 0, sizeof(s));}
    int* operator [](int idx){return s[idx];}
    Matrix (const int arr[MATRIX_N][MATRIX_N]){
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                s[i][j] = arr[i][j] * 3;
    }
    void read(){
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++) {
                scanf("%d", &s[i][j]);
                s[i][j] %= 12;
            }
    }

    friend Matrix operator + (Matrix &a, Matrix &b){
        Matrix c;
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                c[i][j] = (a[i][j] + b[i][j]) % 12;
        return c;
    }

    friend Matrix operator - (Matrix &a, Matrix &b){
        Matrix c;
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                c[i][j] = (a[i][j] - b[i][j] + 12) % 12;
        return c;
    }

    friend bool operator < (const Matrix &a, const Matrix &b){
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                if (a.s[i][j] != b.s[i][j]) return a.s[i][j] < b.s[i][j]; 
        return false;
    }

    bool is_target(){
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                if (s[i][j]) return false; 
        return true;
    }

    void print(){
        puts("");
        for (int i = 0; i < MATRIX_SIZE; i++)
            for (int j = 0; j < MATRIX_SIZE; j++)
                printf("%d%c", s[i][j], j==MATRIX_SIZE-1?'\n':' ');
    }
} moves[11];

map <Matrix, int> vis;  // come from which move

void print_path(Matrix cur){
    if (vis[cur] == -1) return;
    Matrix pre = cur - moves[vis[cur]];
    print_path(pre);
    printf("%d", vis[cur] + 1);
    //cur.print();
    if (!cur.is_target()) putchar(' ');
}

void bfs(Matrix start){
    queue <Matrix> Q;
    vis[start] = -1;
    for (Q.push(start); !Q.empty();){
        Matrix cur = Q.front(); Q.pop();
        if (cur.is_target()) {
            print_path(cur);
            return;
        }
        for (int i = 0; i < 9; i++){
            Matrix nxt = cur + moves[i];
            if (vis[nxt]) continue;
            vis[nxt] = i;
            Q.push(nxt);
        }
    }
}

int main(){
    //freopen("in.txt", "r", stdin);
    for (int i = 0; i < 9; i++){
        moves[i] = Matrix(MOVES[i]);
    }
    Matrix start;
    start.read();
    bfs(start);
    return 0;
}
干脆不取了
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
P1213 [USACO1.4] [IOI1994]时钟 The Clocks
aqfcca的博客
11-18 304
(举例来说 5 2 4 6
洛谷 P1213 时钟 &&IOI 1994 The Clocks
Follow My Heart
10-15 700
IOI 1994 The Clocks 题目描述 考虑将如此安排在一个 3 x 3 行列中的九个时钟: 目标要找一个最小的移动顺序将所有的指针指向12点。下面原表格列出了9种不同的旋转指针的方法，每一种方法都叫一次移动。选择1到9号移动方法，将会使在表格中对应的时钟的指针顺时针旋转90度。 移动方法 受影响的时钟 1 ABDE 2 ABC 3 BCEF 4 ADG 5 BDE
洛谷 P1213 时钟 &&IOI 1994 The Clocks
weixin_30580341的博客
09-09 251
IOI 1994 The Clocks 题目描述 考虑将如此安排在一个 3 x 3 行列中的九个时钟: 目标要找一个最小的移动顺序将所有的指针指向12点。下面原表格列出了9种不同的旋转指针的方法，每一种方法都叫一次移动。选择1到9号移动方法，将会使在表格中对应的时钟的指针顺时...
USACO Section 1.4 The Clocks（DFS）
angtongyou1893的博客
08-29 105
The ClocksIOI'94 - Day 2 Consider nine clocks arranged in a 3x3 array thusly: |-------| |-------| |-------| | | | | | | | |---O | |---O | | O ...
USACO：1.4.2 The Clocks 时钟（IOI 94） 解析
蓝e的专栏
03-29 2381
USACO：The Clocks 时钟（IOI 94） 解析 IOI'94 - Day 2 题目描述： 考虑将如此安排在一个3X3 行列中的九个时钟： |-------| |-------| |-------| | | | | | | | |---O | |---O | | O |
【USACO题库】1.4.2 The Clocks时钟.TJ
weixin_30455023的博客
10-15 153
标题的简介： 【USACO题库】1.4.2 The Clocks——Tj https://jzoj.net/junior/#contest/s...
【宽搜】The Clocks 时钟 (Usaco_Training 1.4)
diying4157的博客
10-18 223
The ClocksIOI'94 - Day 2 Consider nine clocks arranged in a 3x3 array thusly: |-------| |-------| |-------| | | | | | | | |---O | |---O | | O ...
USACO-cha1-sec1.4 The Clocks
JSure的代码库
07-03 1066
The Clocks IOI'94 - Day 2 Consider nine clocks arranged in a 3x3 array thusly: |-------| |-------| |-------| | | | | | | | |---O | |---O | | O |
JZOJ1250.【USACO题库】1.4.2 The Clocks
路人黑的纸巾
05-12 674
题目描述考虑将如此安排在一个 3 x3 行列中的九个时钟:|——-| |——-| |——-|| | | | | | ||—O | |—O | | O || | | | | ||——-| |——-| |——-|A B
usaco 1.4题解
12-04
usaco的某道题的题解
USACO题目The Clocks解答代码
10-21
此题目是USACO（美国计算机奥林匹克竞赛）中的一道编程题，名为"The Clocks"。题目要求解决的问题是找到一种最短的移动顺序，使得一个3x3矩阵中的9个时钟的指针全部指向12点。每个时钟有四个状态：3、6、9和12点，...
USACO1.4~2.3C语言题解
09-05
《USACO1.4~2.3C语言题解》是针对USACO（美国计算机奥林匹克）编程竞赛中1.4至2.3阶段的题目解析，主要使用C语言进行解答。USACO旨在提升高中生的算法设计和编程能力，而C语言作为基础且高效的编程语言，常常被用于...
1_your ride is here_usaco_TheAnswer_YourRideisHere_
10-02
标题 "1_your ride is here_usaco_TheAnswer_YourRideisHere_" 指的是USACO（美国计算机奥林匹克）训练平台上的一个编程练习题目。USACO是一个专门为中学生提供在线编程训练和竞赛的平台，旨在提升参赛者的算法和...
USACO 题目 clocks
10-21
【USACO 题目 clocks】是一道关于算法和逻辑思维的编程竞赛题目，源自美国计算机奥林匹克竞赛（USACO）。题目要求参赛者编写一个程序，解决如何以最少的移动次数调整九个钟表的指针，使它们全部指向12点的问题。 ...
2024Datawhale AI夏令营---基于术语词典干预的机器翻译挑战赛--学习笔记
weixin_61573157的博客
07-15 1078
机器翻译（Machine Translation，简称MT）是自然语言处理领域的一个重要分支，其目标是将一种语言的文本自动转换为另一种语言的文本。机器翻译的发展可以追溯到20世纪50年代，经历了从基于规则的方法、统计方法到深度学习方法的演变过程。当前，机器翻译正朝着更加智能化和个性化方向发展。一方面，结合上下文理解、情感分析等技术，提高翻译的准确性和自然度；另一方面，通过用户反馈和个性化学习，提供更加符合用户需求的翻译服务。同时，跨语言信息检索、多模态翻译等新兴领域也正在成为研究热点。
基于语音识别的会议记录系统
最新发布
qq_51688022的博客
07-18 814
本文简要介绍了本科毕设“基于语音识别的会议记录系统”的开发思路与成果
揭示生成式 AI 在数据叙事和分析中的影响
gongdiwudu的专栏
07-16 1069
在广阔的数据分析领域，改变游戏规则的最深刻的发展之一是生成式人工智能 （GAI）。这是一个激动人心的时刻，人工智能不仅仅是基于历史数据进行处理和预测;它正在创造一些全新的东西，彻底改变数据叙事和分析过程。在最近的一次会议中，我有机会探讨了这项技术创新的基本原理、架构和潜在影响。以下是我们介绍的内容的简明摘要。
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
wwt72的博客
07-17 599
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
p1216 [usaco1.5][ioi1994]数字三角形 number triangles
03-16
题目描述 给定一个数字三角形，从顶部到底部的路径中，每个数字都是从上面的两个数字中选择一个相邻的数字得到的。请找到从顶部到底部的路径，使得路径上的数字总和最大。 输入格式 第一行包含整数 n，表示数字三角形的行数。 接下来 n 行，每行包含若干个整数，表示数字三角形中的数字。 输出格式 输出一个整数，表示从顶部到底部的路径中，数字总和的最大值。 数据范围 1≤n≤500, −10000≤三角形中的整数≤10000 样例 输入样例： 5 5 8 4 3 6 9 7 2 9 5 2 8 7 4 5 输出样例： 44 算法1 (动态规划) $O(n^2)$ 时间复杂度 参考文献 python3 代码 C++ 代码 java 代码 算法2 (暴力枚举) $O(n^3)$ blablabla 时间复杂度 参考文献 C++ 代码

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值