小美的书架

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<set>
using namespace std;
struct C_book//构建书架的结构信息
{
   int lock;
   set<int>book;
}a[10000];
struct Book//构建书的结构信息
{
    int who;
    int row;
}b[10000];
int main()
{
    int n,m,q;
    cin>>n>>m>>q;
    while(q--)//进行操作模拟
    {
        int choose,x,y;
        cin>>choose;
        if(choose==1)
        {
            cin>>x>>y;
            if(b[x].who||a[b[x].row].lock||a[y].lock) continue;
            a[y].book.insert(x);
            b[x].row=y;
        }
        else if(choose==2)
        {
            cin>>y;
            a[y].lock=1;
        }
        else if(choose==3)
        {
            cin>>y;
            a[y].lock=0;
        }
        else if(choose==4)
        {
            cin>>x;
            //printf("x=%d row=%d\n",x,b[x].row);
            if(b[x].who||a[b[x].row].lock||b[x].row==0) cout<<-1<<endl;
            else
            {
                cout<<b[x].row<<endl;
                b[x].who=1;
                b[x].row=0;
                a[b[x].row].book.erase(x);
            }
        }
        else
        {
            cin>>x;
            if(b[x].who==0) continue;
            b[x].who=0;
            b[x].row=0;
        }
    }
    return 0;
}

import java.util.*;
import java.io.*;
 
public class Main {
    public static void main(String[] agrs) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = "";
        while((s = br.readLine()) != null) {
            String[] sc = s.split(" ");
            int m = Integer.parseInt(sc[0]);
            int n = Integer.parseInt(sc[1]);
            int q = Integer.parseInt(sc[2]);
            int[] lock = new int[n + 1];
            Map<Integer, Integer> map = new HashMap<>();
            Set<Integer> set = new HashSet<>();
            for(int i = 0; i < q; i ++) {
                sc = br.readLine().split(" ");
                int a = Integer.parseInt(sc[1]);
                if(Integer.parseInt(sc[0]) == 1) {
                    if(a <= 0 || a > m) {
                        continue;
                    }
                    int b = Integer.parseInt(sc[2]);
                    if(b > n || b <= 0) {
                        continue;
                    }
                    int c = 0;
                    if(map.containsKey(a)) {
                        c = map.get(a);
                    }
                    if(lock[b] == 1 || lock[c] == 1) {
                        continue;
                    }
                    if(set.contains(a)) {
                        continue;
                    }
                    map.put(a, b);
                } else if (Integer.parseInt(sc[0]) == 2) {
                    if(a <= 0 || a > n) {
                        continue;
                    }
                    lock[a] = 1;
                } else if (Integer.parseInt(sc[0]) == 3) {
                    if(a <= 0 || a > n) {
                        continue;
                    }
                    lock[a] = 0;
                } else if (Integer.parseInt(sc[0]) == 4) {
                    if(a <= 0 || a > m) {
                        System.out.println(-1);
                        continue;
                    }
                    int b = map.getOrDefault(a, 0);
                    if(b == 0 || lock[b] == 1) {
                        System.out.println(-1);
                    } else {
                        map.remove(a);
                        set.add(a);
                        System.out.println(b);
                    }
                } else {
                    if(set.contains(a)) {
                        set.remove(a);
                    }
                }
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] params = br.readLine().trim().split(" ");
        int n = Integer.parseInt(params[0]);
        int m = Integer.parseInt(params[1]);
        int q = Integer.parseInt(params[2]);
        int op, x, y;
        boolean[] locked = new boolean[10001];    // 表示第i行书架是否被上锁
        boolean[] hasBook = new boolean[10001];   // 表示第i本书是否在小团手上
        // 记录第i本书在第j行书架上
        int[] pos = new int[10001];
        for(int i = 0; i < q; i++){
            params = br.readLine().trim().split(" ");
            if(params.length == 3){
                op = Integer.parseInt(params[0]);
                x = Integer.parseInt(params[1]);
                y = Integer.parseInt(params[2]);
                // 书架在小团手上，操作无效
                if(hasBook[x]) continue;
                // 这行书架被锁了，操作无效
                if(locked[y]) continue;
                // 如果这本书在一行上了锁的书架上，操作无效
                if(pos[x] != 0 && locked[pos[x]]) continue;
                // 否则将x放在第y行书架上
                pos[x] = y;
            }else{
                op = Integer.parseInt(params[0]);
                if(op == 2){
                    // 直接加锁
                    y = Integer.parseInt(params[1]);
                    locked[y] = true;
                }else if(op == 3){
                    // 直接去掉锁
                    y = Integer.parseInt(params[1]);
                    locked[y] = false;
                }else if(op == 4){
                    x = Integer.parseInt(params[1]);
                    // 如果x已经放在了书架上，且该层书架又没上锁，就直接输出
                    if(pos[x] != 0 && !locked[pos[x]]){
                        System.out.println(pos[x]);
                        pos[x] = 0;
                        hasBook[x] = true;
                    }else
                        System.out.println(-1);
                }else{
                    x = Integer.parseInt(params[1]);
                    // 这本书不在小团手上，操作无效
                    if(!hasBook[x]) continue;
                    // 否则直接令小团失去这本书
                    hasBook[x] = false;
                }
            }
        }
    }
}

from collections import defaultdict
n, m, q = map(lambda x: int(x), input().split())

des_lock = [False]*(m+1)
book_des = {}
tuan = set()

for _ in range(q):
    x, y = None, None
    data = list(map(lambda x: int(x), input().split()))

    if data[0]==1: # 编号为3
        x, y = data[1], data[2]
        if x in tuan&nbs***bsp;des_lock[y]: # 书在小团手中或书架被上锁
            continue
        
        if x in book_des and des_lock[book_des[x]]:
            continue

        book_des[x] = y

    if data[0]==2:
        des_lock[data[1]] = True
    if data[0]==3:
        des_lock[data[1]] = False
    
    if data[0]==4:
        x = data[1]
        if x in book_des and not des_lock[book_des[x]]: # 在书架上且没加锁
            tuan.add(x)
            print(book_des[x])
            book_des.pop(x)
        else:
            print(-1)

    if data[0]==5:
        x = data[1]
        if x not in tuan:
            continue
        tuan.remove(x)

import java.util.HashMap;
import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        HashMap<Integer, Integer> lock = new HashMap<>();
        HashMap<Integer, Integer> book = new HashMap<>();
        HashMap<Integer, Integer> brrowr = new HashMap<>();
     
        String[] str;
        str = br.readLine().split(" ");
        int n = Integer.parseInt(str[0]);
        int m = Integer.parseInt(str[1]);
        int q = Integer.parseInt(str[2]);
        ArrayList<Integer> ret = new ArrayList<Integer>();
        for(int i = 0; i < q; i++){
            str = br.readLine().split(" ");
            if(str[0].equals("1")){
                int a = Integer.parseInt(str[1]);
                int b = Integer.parseInt(str[2]);
                if(!brrowr.containsKey(a) && !lock.containsKey(b)){
                    if(book.containsKey(a) && lock.containsKey(book.get(a))){
                        continue;
                    }
                    book.put(a, b);
                }
    
            }else if (str[0].equals("2")) {
                int loc = Integer.parseInt(str[1]);
                lock.put(loc, 1); // 表示对第loc行上锁
            }else if (str[0].equals("3")) { //移除第loc行锁
                int loc = Integer.parseInt(str[1]);
                if(lock.containsKey(loc)){
                    lock.remove(loc);
                }
            }else if (str[0].equals("4")) {
                int bn = Integer.parseInt(str[1]);
                int line;
                if(book.containsKey(bn) && !lock.containsKey(line = book.get(bn))){
                    book.remove(bn);
                    brrowr.put(bn, 1);
                    ret.add(line);
                }else{// 未上锁
                    ret.add(-1);
                }
            }else{
                int bn = Integer.parseInt(str[1]);
                if(!brrowr.containsKey(bn)){
                    continue;
                }else{
                    brrowr.remove(bn);
                }
            }
        }
        for(int i = 0; i < ret.size(); i++){
            bw.write(Integer.toString(ret.get(i)));
            bw.newLine();
            bw.flush();
        }
    }
}

import java.io.*;
import java.util.HashMap;

public class Main{
public static void main(String[] args) throws IOException {
        //经典输入数字
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        String[]lineargs = br.readLine().trim().split(" ");
        int Q = Integer.parseInt(lineargs[2]);
        //statemapp 1代表在书架 2代表被小团借 0或者为空都代表在小美手里
        HashMap<Integer,Integer>stateMap = new HashMap<>();
        //书id->书架id
        HashMap<Integer,Integer>shelfMap = new HashMap<>();
        //shelfLock
        HashMap<Integer,Boolean>shelfLock = new HashMap<>();
        for(int i=0;i<Q;i++){
            lineargs = br.readLine().trim().split(" ");
            if(lineargs[0].compareTo("1") == 0){
                //add book
                int bookId = Integer.parseInt(lineargs[1]);
                int shelfId = Integer.parseInt(lineargs[2]);
                if(stateMap.containsKey(bookId)){
                    int state = stateMap.get(bookId);
                    if(state == 2)
                        continue;
                    if(state == 1){
                        int oldShelfId = shelfMap.get(bookId);
                        if(shelfLock.containsKey(oldShelfId)&&shelfLock.get(oldShelfId)){
                            //lock
                            continue;
                        }
                    }
                }
                if(shelfLock.containsKey(shelfId)&&shelfLock.get(shelfId)){
                    //new lock
                    continue;
                }
                stateMap.put(bookId, 1);
                shelfMap.put(bookId, shelfId);
            } else if(lineargs[0].compareTo("2") == 0){
                int shelfId = Integer.parseInt(lineargs[1]);
                shelfLock.put(shelfId, true);
            } else if(lineargs[0].compareTo("3") == 0){
                int shelfId = Integer.parseInt(lineargs[1]);
                shelfLock.put(shelfId, false);
            } else if(lineargs[0].compareTo("4") == 0){
                int bookId = Integer.parseInt(lineargs[1]);
                if(stateMap.containsKey(bookId)&&stateMap.get(bookId) == 1){
                    int shelfId = shelfMap.get(bookId);
                    if(!shelfLock.containsKey(shelfId) || shelfLock.get(shelfId) == false){
                        stateMap.put(bookId, 2);
                        shelfMap.remove(bookId);
                        writer.write(Integer.toString(shelfId));
                        writer.write("\n");
                        continue;
                    }
                }
                writer.write("-1\n");
            } else if(lineargs[0].compareTo("5") == 0){
                int bookId = Integer.parseInt(lineargs[1]);
                if(stateMap.containsKey(bookId)&&stateMap.get(bookId) == 2){
                    stateMap.put(bookId, 0); //归还
                }
            }
        }
        writer.flush();
    }
}