题解，java学习日志（3）

题解

U - 速算24点

D - Bank（标记）

E.2xN Grid

C.Findand Replace

D.Odd Queries

搜索题组

U - 速算24点
思路：map映射将特定字符转化成规定数字，之后两个for循环枚举所有组合，dfs+,-,*,/操作+回溯，在/的操作中
进行判断，最后判断合成数是否==24
 

#include<algorithm>
#include<iostream>
#include<map>
using namespace std;
int arr[4];
char ret[4][10];
map<string, int> tran;
bool dfs(int n) {
    if (1 == n) {
        return arr[0] == 24;
    }
    for (int i = 0; i <n; i++) {
        for (int j = i + 1; j < n; j++) {
            int a = arr[i], b = arr[j];
            arr[j] = arr[n - 1];
            arr[i] = a + b;
            if (dfs(n - 1)) return true;
            arr[i] = a - b;
            if (dfs(n - 1)) return true;
            arr[i] = b - a;
            if (dfs(n - 1)) return true;
            arr[i] = a * b;
            if (dfs(n - 1)) return true;
            if (b != 0 && 0 == a % b) {
                arr[i] = a / b;
                if (dfs(n - 1)) return true;
            }
            if (a != 0 && 0 == b % a) {
                arr[i] = b / a;
                if (dfs(n - 1)) return true;
            }
            arr[i] = a;                    //回溯
            arr[j] = b;
        }
    }
    return false;
}
void init() {
    tran["A"] = 1;
    tran["2"] = 2;
    tran["3"] = 3;
    tran["4"] = 4;
    tran["5"] = 5;
    tran["6"] = 6;
    tran["7"] = 7;
    tran["8"] = 8;
    tran["9"] = 9;
    tran["10"] = 10;
    tran["J"] = 11;
    tran["Q"] = 12;
    tran["K"] = 13;
}
bool solve() {
    for (int i = 0; i < 4; i++) {
        arr[i] = tran[ret[i]];
    }
    if (dfs(4)) 
    return true;
    return false;
}
int main() {
    init();
    while (~scanf("%s %s %s %s", ret[0], ret[1], ret[2], ret[3])) {
        puts(solve() ? "Yes" : "No");
    }
    return 0;
}

AtCoder Beginner Contest 294

D - Bank（标记）
思路：用set的数据结构即可，不过在比赛中忘记了set的输出方式，总是报错
 

#include<iostream>
#include<queue>;
#include<set>
using namespace std;
const int maxn =2e5;
queue<int>q;
set<int>s;
int main() {
    ios::sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        q.push(i);
    }
    int flag = 0;
    for (int i = 1; i <= m; i++) {
        int a;
        cin >> a;
        if (a == 1) {
            s.insert(q.front());
            q.pop();
        }
        if (a == 2) {
            int c;
            cin >> c;
            s.erase(c);
        }
        if (a == 3) {
            cout << *s.begin() << '\n';
        }
    }
    return 0;
}

E.2xN Grid
思路：第一行用一个数组a储存元素大小，一个数组b存储元素个数大小，第二行对第一行进行比较，将重叠部分加上
 

#include<iostream>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 10;
ll a[maxn], b[maxn];
int main() {
    ios::sync_with_stdio(false);
    ll L, n, m;
    cin >> L >> n >> m;
    ll res = 0;
    for (int i = 1; i <= n; i++)
        cin >> a[i] >> b[i];
    ll l;
    for (int v, tp = 1; m--;) {
        cin >> v >> l;
        while (l) {
            ll len = min(l, b[tp]);               //判断部分，防止越界
            if (v == a[tp])res += len;
            b[tp] -= len, l -= len;
            if (!b[tp])++tp;
        }
    }
    cout << res << '\n';
}

Codeforces Round 859 (Div. 4)

C.Findand Replace
规律：两个相同的字母中间隔偶数的字母则一定不能形成01串，反之可以,
例:abaa,第1个a与第2个a隔1个，第3个a与第2个a隔0个，第3个a与第1个a隔2个，所以相同字母只需计算与第一个的距离
 

#include<iostream>
#include<queue>
using namespace std;
const int maxn = 1e3;
string s;
int cnt[maxn];
int main()
{
    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--) {
        memset(cnt, -1, sizeof(cnt));
        int n;
        cin >> n;
        cin >> s;
        bool flag = 0;
        for (int i = 0; i < s.size(); i++) {
            if (cnt[s[i]] == -1)
                cnt[s[i]] = i;
            else {
                if ((i - cnt[s[i]]) % 2) {
                    flag = 1;
                    break;
                }
            }
        }
        if (!flag)
            cout << "YES" << '\n';
        else
            cout << "NO" << '\n';
    }
    return 0;
}

D.Odd Queries
前缀和,赋值操作单独提出来取模
 

#include<iostream>
using namespace std;
const int maxn = 2e5 + 10;
typedef long long ll;
ll a[maxn], sum[maxn];
int main()
{
    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--) {
        int n, m;
        cin >> n >> m;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
            sum[i] = a[i] + sum[i - 1];
        }
        for (int i = 1; i <= m; i++) {
            int l, r;
            ll v;
            cin >> l >> r >> v;
            ll t = ((l - r + 1) * v) % 2;
            ll ans = sum[l - 1] + sum[n] - sum[r];
            if ((ans + t) % 2)
                cout << "YES" << '\n';
            else
                cout << "NO" << '\n';
        }
    }
    return 0;
}

Java学习日志（3）

java超星项目考虑学习
一.java基于Swing的图形界面设计（GUI）（熟悉工具操作）
引入：
   AWT,Java最早的界面库。（java.awt）
     Swing,是对AWT的扩展。（javax.swing）
一个 Java 的图形界面，由各种不同类型的“元素”组成，这些“元素”统一被称为 组件（Component）。
Swing 包含了构建图形界面（GUI）的各种组件，如: 窗口、标签、按钮、文本框等。
Swing 组件在javax.swing.*包下，类名均以 J 开头，例如: JFrame、JLabel、JButton等。
组件按照不同的功能，可分为 顶层容器、中间容器、基本组件
顶层容器 属于窗口类组件，继承自java.awt.Window；
中间容器 和 基本组件 继承自javax.swing.JComponent。
列举：
（顶层容器）：窗口类组件，可以独立显示，一个图形界面至少需要一个窗口
JFrame    一个普通的窗口（绝大多数 Swing 图形界面程序使用 JFrame 作为顶层容器）
JDialog    对话框
（中间容器）：中间容器充当基本组件的载体，不可独立显示。中间容器可以添加若干基本组件（也可以嵌套添加中间容器），对容器内的组件进行管理，类似于给各种复杂的组件进行分组管理。最顶层的一个中间容器必须依托在顶层容器（窗口）内。
JPanel    一般轻量级面板容器组件
JScrollPane    带滚动条的，可以水平和垂直滚动的面板组件
JSplitPane    分隔面板
JTabbedPane    选项卡面板
JLayeredPane    层级面板
JMenuBar    菜单栏
JToolBar    工具栏
JPopupMenu    弹出菜单
JInternalFrame    内部窗口
 （基本组件）：直接实现人机交互的组件。所有的组件都可以通过add()方法加入容器中。
JLabel    标签                                              JButton    按钮
JRadioButton    单选按钮                                    JCheckBox    复选框
JToggleButton    开关按钮                                    JTextField    文本框
JPasswordField    密码框                                      JTextArea    文本区域
JComboBox    下拉列表框                                        JList    列表
JProgressBar    进度条                                      JSlider    滑块
选取器组件:
JFileChooser    文件选取器
JColorChooser    颜色选取器
其他较为复杂的基本组件:
JTable    表格
JTree    树
（1）.窗口
JFrame() 创建一个无标题的窗口
JFrame(String s) 创建标题为s的窗口
public void setVisible(boolean b) 设置窗口是否可见，窗口默认不可见
public void dispose() 撤销当前的窗口，并释放当前窗口所使用的资源
public void setDefaultCloseOperation(int operation)  设置单击窗体右上角关闭图标后，程序会做出怎样的处理
    WindowConstants.DISPOSE_ON_CLOSE 隐藏当前的窗口，并释放窗体占有的其他资源
    WindowConstants.DO_NOTHING_ON_CLOSE 什么也不做
    WindowConstants.HIDE_ON_CLOSE 隐藏当前窗口
    WindowConstants.EXIT_ON_CLOSE 结束窗口所在的应用程序
例：

import javax.swing.JFrame;
import javax.swing.WindowConstants;
import java.awt.Color;
import java.awt.Font;
public class Windows {
    public static void main(String[] args) {
        JFrame window1 = new JFrame("撤销窗口"); //创建标题名
        JFrame window2 = new JFrame("退出程序");
        window1.setBounds(0,0,400,200);// 显示X轴位置,显示Y轴位置 ,宽,长
        window2.setBounds(400,0,400,200);
        Font font1 = new Font("宋体", Font.BOLD, 50);//设置字形，字体和字号
        window1.setFont(font1);
        window1.setLocationRelativeTo(null);             // 把窗口位置设置到屏幕中心
         window1.getContentPane().setBackground(Color.BLACK);  //设置背景颜色
        window1.setVisible(true); // 窗口默认是不可见的
        window1.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        //设置单击窗体右上角关闭图标后，程序会做出怎样的处理。
        window2.setVisible(true);
        window2.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
}

(2).菜单条、菜单、菜单项
顺序关系：菜单条-->菜单-->菜单项
菜单条
JComponent类的子类 JMenubar 负责创建菜单条，即JMenubar 的一个实例就是一个菜单条，JFrame类用一个把菜单条放到窗口的方法：
setJMenuBar( JMenuBar bar);
该方法将菜单条添加到窗口的顶端，需要注意的是，只能向窗口添加一个菜单条。
菜单
JComponent类的子类JMenu负责创建菜单，即JMenu的一个实例就是一个菜单。
菜单项
JComponent类的子类JMenuItem负责创建菜单项，即JMenuItem的一个实例就是一个菜单项
 JMenuItem(String text, Icon icon) 
嵌入子菜单
JMenu是JMenuItem的子类，因此菜单本身也是一个菜单项，当把一个菜单看作菜单项添加到摸个菜单中时，称这个菜单为子菜单。
菜单上的图标
可以用 图标类Icon声明一个图标，使用ImageIcon类创建一个图标。
Icon icon = new ImageIcon("a.png");
然后菜单项调用setIcon(Icon icon)设置图标
例：

public class Main {
    public static void main(String[] args) {
        WindowMenu win = new WindowMenu("带窗口的菜单", 20, 30, 400, 500);
    }
}
import java.awt.event.*；
import javax.swing.*;

/*
 * 自定义窗口WindowMenu
 */

public class WindowMenu extends JFrame {
    JMenuBar menubar;               //菜单栏
    JMenu menu, subMenu;       //菜单
    JMenuItem item1, item2;          //菜单项

    public WindowMenu() {
    }

    public WindowMenu(String s, int x, int y, int w, int h) {
        init(s);
        setLocation(x, y);       //窗口位置
        setSize(w, h);           //窗口大小
        setVisible(true);         //窗口默认是不可见的
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);  //单击窗体右上角关闭图标后,隐藏当前的窗口，并释放窗体占有的其他资源
    }

    void init(String s) {
        setTitle(s);                 //窗口名称
        menubar = new JMenuBar();
        menu = new JMenu("菜单"); // JMnud的实例就是一个菜单

        /**
         * 一级菜单项
         */
        subMenu = new JMenu("软件项目"); // 子菜单
        item1 = new JMenuItem("Java话题"); // 创建菜单项
        //为菜单项设置图标
        ImageIcon icon = new ImageIcon("a.png");   //图片
        item1.setIcon(icon);

        //使用JMenuItem的构造方法设置图标
        item2 = new JMenuItem("动画话题", new ImageIcon("b.png"));
        item1.setAccelerator(KeyStroke.getKeyStroke('A'));       //键盘操作A
        item2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_MASK));   //键盘操作ctrl+s
        menu.add(item1);
        menu.addSeparator();
        menu.add(item2);
        menu.add(subMenu);
        /**
         * 添加二级菜单项
         */
        subMenu.add(new JMenuItem("汽车销售系统", new ImageIcon("c.png")));
        subMenu.add(new JMenuItem("农场信息系统", new ImageIcon("d.png")));
        menubar.add(menu); // 菜单条中加入菜单
        setJMenuBar(menubar); // 添加一个菜单条

    }
}

（3）常用组件与布局
文本框：使用JComponent的子类JTextField创建文本框。文本框的允许用户输入单行文本。
文本区：使用JComponent的子类JButton类创建按钮，允许用户单击按钮。
标签：使用JComponent的子类JLabel类创建标签，标签为用户提供信息提示。
选择框：使用JComponent的子类JCheckBox类来创建选择框，为用户提供多项悬着。选择框提供两种状态，选中和未选中，用户通过单击该组件切换状态。
单选按钮：使用JComponent的子类的JRadioButton类创建单项选择框，为用户提供单项选择。
下拉列表：使用JComponent的子类的JComboBox类来创建下拉列表，为用户提供下拉列表。
密码框：使用JComponent的子类的子类JPasswordField创建密码框，允许输入单行密码，密码框默认回显字符是“*”，也可以通过setEchoChar(char c)来重新设置回显字符。密码框调用char[] getPassword()方法可以返回实际的密码。
例子：
 

public class Main {
    public static void main(String[] args) {
        ComponentInWindow win = new ComponentInWindow();
        win.setBounds(100, 100, 320, 310);
        win.setTitle("常用组件");
    }
}

import java.awt.FlowLayout;
import javax.swing.*;
public class ComponentInWindow extends JFrame {

    JTextField text;        //文本框,允许用户输入单行文本。
    JButton button;        //创建按钮，允许用户单击按钮。
    JCheckBox checkBox1, checkBox2, checkBox3;   //创建选择框，为用户提供多项悬着。选择框提供两种状态，选中和未选中，用户通过单击该组件切换状态。
    JRadioButton radio1, radio2;         //创建单项选择框，为用户提供单项选择。
    ButtonGroup group;                   // RadioButton类常常搭配ButtonGroup类一同使用,表明同一组button
    JComboBox<Object> comBox;   //创建下拉列表，为用户提供下拉列表。
    JTextArea area;
    JPasswordField password;   //创建密码框，允许输入单行密码，密码框默认回显字符是“*”

    public ComponentInWindow() {
        init();
        setVisible(true);      // //窗口默认是不可见的
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//单击窗体右上角关闭图标后,隐藏当前的窗口，并释放窗体占有的其他资源
    }

    void init() {
        setLayout(new FlowLayout()); // 设置布局

        add(new JLabel("文本框:"));
        text = new JTextField(10);
        add(text);

        add(new JLabel("按钮:"));
        button = new JButton("确认");
        add(button);

        add(new JLabel("密码框:"));
        password = new JPasswordField(10);
        add(password);

        add(new JLabel("按钮:"));
        button = new JButton("确认");
        add(button);

        add(new JLabel("选择框:"));
        checkBox1 = new JCheckBox("喜欢音乐");
        checkBox2 = new JCheckBox("喜欢旅游");
        checkBox3 = new JCheckBox("喜欢篮球");
        add(checkBox1);
        add(checkBox2);
        add(checkBox3);

        add(new JLabel("单选按钮:"));
        group = new ButtonGroup();
        radio1 = new JRadioButton("男");
        radio2 = new JRadioButton("女");
        group.add(radio1);
        group.add(radio2);
        add(radio1);
        add(radio2);

        add(new JLabel("下拉列表:"));
        comBox = new JComboBox<>();
        comBox.addItem("音乐天地");
        comBox.addItem("武术天地");
        comBox.addItem("象棋乐园");
        add(comBox);

        add(new JLabel("文本区"));
        area = new JTextArea(6, 13);// 文本区设置行数和列数
        add(new JScrollPane(area));
    }
}

（3）常见容器
 JComponent 是 Comtainer的 子类，因此 JComponent 的子类创建的组件也都是容器，但我们很少将 JButton、JTextField、JCheckBox 等组件当容器来使用。JComponent 专门提供了一些经常用来添加组建的容器。相对于底层容器 JFrame ,下面提到的容器被习惯地称为中间容器，中间容器必须被添加到底层容器中才能发挥作用。
Jpanel面板
我们会经常使用 JPanel 创建一个面板，再向这个面板添加组件，然后把这个面板添加到其他容器中。JPanel 面板的默认布局是 FlowLayout 布局。
滚动窗格 JScrollPane
拆分窗格 JSpitPane
分层窗格 JLayeredPane
（4）常用布局
当把组件添加到容器中时，希望控制组件在容器中的位置，这就需要用到布局设计。
容器可以使用方法设置自己的布局。
FlowLayout 布局（流式布局，按组件加入的顺序，按水平方向排列，排满一行换下一行继续排列。）
FlowLayout 类创建的对象称作 FlowLayout 型布局。FlowLayout 型布局是 JPanel 型布局的默认布局，即 JPanel 及其子类创建的容器对象，如果不专门指定布局，则他们的布局就是 FlowLayout
方式应用：
setLayout(new FlowLayout());
通过add 方法将组件按先后顺序，从左到右，默认水平和垂直间隙是 5 个像素的方式排列。组件的大小为默认的最佳大小，例如，控件的大小刚好能保证显示其上面的名字。
列举：
GridLayout    网格布局，把Container按指定行列数分隔出若干网格，每一个网格按顺序放置一个控件。
GridBagLayout    网格袋布局，按网格划分Container，每个组件可占用一个或多个网格，可将组件垂直、水平或沿它们的基线对齐。
BoxLayout    箱式布局，将Container中的多个组件按 水平 或 垂直 的方式排列。
GroupLayout    分组布局，将组件按层次分组（串行 或 并行），分别确定 组件组 在 水平 和 垂直 方向上的位置。
CardLayout    卡片布局，将Container中的每个组件看作一张卡片，一次只能显示一张卡片，默认显示第一张卡片。
BorderLayout    边界布局，把Container按方位分为 5 个区域（东、西、南、北、中），每个区域放置一个组件。
SpringLayout    弹性布局，通过定义组件四条边的坐标位置来实现布局。
null    绝对布局，通过设置组件在Container中的坐标位置来放置组件。

二.处理事件（处理组件的点击或者选择事件。）
1.事件处理模式
事件源：
能够产生处理了事件的对象都可以成为事件源，如文本框，按钮，下拉式列表等。也就是说，事件源必须是一个对象，而且这个对象必须是Java认为能够发生事件的对象。
监视器：
我们需要一个对象对事件源进行监视，以便对发生的事件作出处理。事件源通过调用相应的方法将某个对象注册为自己的监视器。
例如，对于文本框，这个方法是：
addActionListener(监视器);
对于注册监视器的文本框，在文本框获得焦点后，当用户对文本框进行操作，如按下回车键，Java 运行环境就会自动用 ActionEvent 类创建一个对象，触发 ActionEvent 事件 。对文本框进行相应的操作就会导致相应的事件发生，并通知监视器，监视器就会做出相应的处理。
处理事件的接口：
为了让监视器这个对象能够对事件源发生的事件进行处理，创建该视图对象的类必须实现相应的接口，即必须在类体中重写接口的所有方法，那么当事件源发生事件是，监视器会自动调用类中被重写的接口方法。
2.ActionEvent 事件
ActionEvent 事件源
文本框、按钮、菜单项、密码框、和单选按钮都可以触发事件，都可以成为事件源。
注册监视器
能触发 ActionEvent 事件的组件，使用 addActionListener(ActionListener listen),将实现 ActionListener 接口的类的实例注册为事件源的监视器。
ActionListener 接口
ActionListener 接口位于 java.awt.event包中，该接口只有一个方法
例子：

public void actionPerformed(ActionEvent e)
public class Main {
    public static void main(String[] args) {
        WindowActionEvent win = new WindowActionEvent();
        win.setBounds(100,100,310,260);
        win.setTitle("处理ActionEvent事件");
    }
}

import java.awt.FlowLayout;
import java.awt.HeadlessException;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class WindowActionEvent extends JFrame {
    JTextField text;          //文本框，用来编辑单行的文本。
    ReaderListen listener;         //监听器

    public WindowActionEvent() throws HeadlessException {
        init();
        setVisible(true);   //窗口默认是不可见的
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//单击窗体右上角关闭图标后,隐藏当前的窗口，并释放窗体占有的其他资源
    }

    void init() {
        setLayout(new FlowLayout());          //布局
        text = new JTextField(10);
        listener = new ReaderListen();      //监听器
        text.addActionListener(listener);
        add(text);
    }
}

class ReaderListen implements ActionListener {

    @Override     //@Override 注解是用来指定方法重写的，只能修饰方法并且只能用于方法重写，不能修饰其它的元素
    public void actionPerformed(ActionEvent e) {               //ActionListener事件 接口
        //实现功能
    }
}