acwing::acwing1929::Solution类 参考

#include <acwing.h>

Public 成员函数
unsigned int	count_reflect (direction d, unsigned int x, unsigned int y)
	获取反射的次数 更多...
unsigned(*	get_record (direction d))[1000]
	获取记录类型 更多...
int	main (istream &cin, ostream &cout)

Private 属性
unsigned int	down_map [1000][1000] = {0}
	在每格向下时可以被反射的次数 更多...
unsigned int	left_map [1000][1000] = {0}
	在每格向左时可以被反射的次数 更多...
unsigned short	m {}
	列数 更多...
char	mirrors [1000][1000] = {0}
	镜子 更多...
unsigned short	n {}
	行数 更多...
unsigned int	right_map [1000][1000] = {0}
	在每格向右时可以被反射的次数 更多...
unsigned int	up_map [1000][1000] = {0}
	在每格向上时可以被反射的次数 更多...

详细描述

在文件 acwing.h 第 581 行定义.

成员函数说明

count_reflect()

unsigned int acwing::acwing1929::Solution::count_reflect	(	direction	d,
		unsigned int	x,
		unsigned int	y
	)

获取反射的次数

参数

d	方向
x	横坐标
y	纵坐标

返回

在(x,y)以d方向前进的光距离离开剩下的反射次数

在文件 acwing.cpp 第 1605 行定义.

                                                                                        {
            if(x == 0 || y == 0 || x == n - 1 || y == m - 1) {
                unsigned int count  = 0;
                int current_x       = x;
                int current_y       = y;
                direction current_d = d;
                auto path           = unordered_set<step, step_hash, step_equal>();
                while(0 <= current_x && current_x < n && 0 <= current_y && current_y < m) {
                    auto s = step(current_d, current_x, current_y);
                    if(!path.contains(s)) {
                        path.insert(s);
                    } else {
                        return -1;
                    }
 
                    const auto *record = get_record(d);
                    if((*record)[x][y] != 0) {
                        return count + (*record)[x][y];
                    }
                    current_d = reflect(current_d, mirrors[current_x][current_y]);
                    count++;
                    (*get_record(!current_d))[current_x][current_y] = count;
                    switch(current_d) {
                        case left: {
                            current_y--;
                            break;
                        }
                        case right: {
                            current_y++;
                            break;
                        }
                        case up: {
                            current_x--;
                            break;
                        }
                        case down: {
                            current_x++;
                            break;
                        }
                    }
                }
                return count;
            }
            return -1;
        }

引用了 acwing::acwing1929::down, get_record(), acwing::acwing1929::left, m, mirrors, n, acwing::acwing1929::reflect(), acwing::acwing1929::right , 以及 acwing::acwing1929::up.

被这些函数引用 main().

get_record()

unsigned int(* acwing::acwing1929::Solution::get_record

(

direction

d

)

)[1000]

获取记录类型

参数

d

方向

返回

方向对应的记录

在文件 acwing.cpp 第 1651 行定义.

                                                                    {
            switch(d) {
                case left: {
                    return &left_map;
                }
                case right: {
                    return &right_map;
                }
                case up: {
                    return &up_map;
                }
                case down: {
                    return &down_map;
                }
            }
            return nullptr;
        }

引用了 acwing::acwing1929::down, acwing::acwing1929::left, acwing::acwing1929::right , 以及 acwing::acwing1929::up.

被这些函数引用 count_reflect().

main()

int acwing::acwing1929::Solution::main	(	istream &	cin,
		ostream &	cout
	)

在文件 acwing.cpp 第 1581 行定义.

                                                      {
            cin >> n >> m;
            for(unsigned short i = 0; i < n; i++) {
                for(unsigned short j = 0; j < m; j++) {
                    cin >> mirrors[i][j];
                }
            }
            int maximum = -1;
            for(unsigned short j = 0; j < m; j++) {
                maximum = max(maximum, static_cast<int>(count_reflect(down, 0, j)));
            }
            for(unsigned short j = 0; j < m; j++) {
                maximum = max(maximum, static_cast<int>(count_reflect(up, n - 1, j)));
            }
            for(unsigned short i = 0; i < n; i++) {
                maximum = max(maximum, static_cast<int>(count_reflect(right, i, 0)));
            }
            for(unsigned short i = 0; i < n; i++) {
                maximum = max(maximum, static_cast<int>(count_reflect(left, i, m - 1)));
            }
            cout << maximum;
            return 0;
        }

引用了 count_reflect(), acwing::acwing1929::down, acwing::acwing1929::left, m, mirrors, n, acwing::acwing1929::right , 以及 acwing::acwing1929::up.

类成员变量说明

down_map

unsigned int acwing::acwing1929::Solution::down_map[1000][1000] = {0}

private

在每格向下时可以被反射的次数

在文件 acwing.h 第 592 行定义.

left_map

unsigned int acwing::acwing1929::Solution::left_map[1000][1000] = {0}

private

在每格向左时可以被反射的次数

在文件 acwing.h 第 586 行定义.

m

unsigned short acwing::acwing1929::Solution::m {}

private

列数

在文件 acwing.h 第 596 行定义.

被这些函数引用 count_reflect() , 以及 main().

mirrors

char acwing::acwing1929::Solution::mirrors[1000][1000] = {0}

private

镜子

在文件 acwing.h 第 584 行定义.

被这些函数引用 count_reflect() , 以及 main().

n

unsigned short acwing::acwing1929::Solution::n {}

private

行数

在文件 acwing.h 第 594 行定义.

被这些函数引用 count_reflect() , 以及 main().

right_map

unsigned int acwing::acwing1929::Solution::right_map[1000][1000] = {0}

private

在每格向右时可以被反射的次数

在文件 acwing.h 第 588 行定义.

up_map

unsigned int acwing::acwing1929::Solution::up_map[1000][1000] = {0}

private

在每格向上时可以被反射的次数

在文件 acwing.h 第 590 行定义.

---

该类的文档由以下文件生成:

• acwing.h
• acwing.cpp