https://lo-li.net/ zh-CN A site since 2012 Thu, 17 Aug 2023 12:24:00 +0000 Thu, 17 Aug 2023 12:24:00 +0000 https://lo-li.net/1420-1420.html https://lo-li.net/1420-1420.html Thu, 17 Aug 2023 12:24:00 +0000 rin <trans data-src="# Review of receivers"># Review of receivers</trans> <trans data-src="When a value receiver is defined, Go automatically generates a corresponding pointer receiver.">When a value receiver is defined, Go automatically generates a corresponding pointer receiver.</trans> <trans data-src="Auto-generating a pointer receiver causes differences in the method sets of pointer types and value types.">Auto-generating a pointer receiver causes differences in the method sets of pointer types and value types.</trans> <trans data-src="For example, take the `Len()` method below, Go will automatically generate a corresponding pointer receiver version:">For example, take the `Len()` method below, Go will automatically generate a corresponding pointer receiver version:</trans> <trans data-src="```go">```go</trans> <trans data-src="type List []int">type List []int</trans> <trans data-src="func (l List) Len() int { return len(l) }">func (l List) Len() int { return len(l) }</trans> <trans data-src="// func (l *List) Len() int { ... }">// func (l *List) Len() int { ... }</trans> <trans data-src="func (l *List) Append(val int) { *l = append(*l, val) }">func (l *List) Append(val int) { *l = append(*l, val) }</trans> <trans data-src="```">```</trans> <trans data-src="For type `List`, its method set includes:">For type `List`, its method set includes:</trans> <trans data-src="- `Len() int`">- `Len() int`</trans> <trans data-src="For type `*List`, the method set includes:">For type `*List`, the method set includes:</trans> <trans data-src="- `Len() int`">- `Len() int`</trans> <trans data-src="- `Append(int)`">- `Append(int)`</trans> <trans data-src="This difference affects the use of interfaces:">This difference affects the use of interfaces:</trans> <trans data-src="```go">```go</trans> <trans data-src="type Container interface {">type Container interface {</trans> <trans data-src="Len() int">Len() int</trans> <trans data-src="Append(int)">Append(int)</trans> <trans data-src="}">}</trans> <trans data-src="var _ Container = List{} // no">var _ Container = List{} // no</trans> <trans data-src="var _ Container = &List{}">var _ Container = &List{}</trans> <trans data-src="```">```</trans> <trans data-src="However, for the type's own pointer and value, there appears to be no difference, both can call the two methods:">However, for the type's own pointer and value, there appears to be no difference, both can call the two methods:</trans> <trans data-src="```go">```go</trans> <trans data-src="l := List{}">l := List{}</trans> <trans data-src="pl := &List{}">pl := &List{}</trans> <trans data-src="// List only implements `Len`">// List only implements `Len`</trans> <trans data-src="l.Append(42) // how does Go find `Append`?">l.Append(42) // how does Go find `Append`?</trans> <trans data-src="// (&l).">// (&l).</trans> <trans data-src="Append(42)">Append(42)</trans> <trans data-src="l.Len() // gets 1">l.Len() // gets 1</trans> <trans data-src="// *List implements `Append` explicitly, `Len` implicitly">// *List implements `Append` explicitly, `Len` implicitly</trans> <trans data-src="pl.Append(6)">pl.Append(6)</trans> <trans data-src="pl.Len() // gets 1">pl.Len() // gets 1</trans> <trans data-src="```">```</trans> <trans data-src="In the `List` method set, there is no `Append(int)`. ">In the `List` method set, there is no `Append(int)`. </trans> <trans data-src="Go converts the corresponding call to `(&l).">Go converts the corresponding call to `(&l).</trans> <trans data-src="Append(42)` to implement this which is a syntactic sugar.">Append(42)` to implement this which is a syntactic sugar.</trans> <trans data-src="However, if you cannot get the address of an object of a certain type, this feature does not work. Non-addressable types include `map` and `interface` and some other, as shown below:">However, if you cannot get the address of an object of a certain type, this feature does not work. Non-addressable types include `map` and `interface` and some other, as shown below:</trans> <trans data-src="```go">```go</trans> <trans data-src="m := map[string]List{"list1": List{}}">m := map[string]List{"list1": List{}}</trans> <trans data-src="p := &m["list1"] // cannot take the address of m["list1"] (map index expression of type List)">p := &m["list1"] // cannot take the address of m["list1"] (map index expression of type List)</trans> <trans data-src="var i interface{} = List{}">var i interface{} = List{}</trans> <trans data-src="p = &i.(List) // cannot take the address of i.(List)">p = &i.(List) // cannot take the address of i.(List)</trans> <trans data-src="```">```</trans> <trans data-src="Because the map stores `List`, you can directly call `List.">Because the map stores `List`, you can directly call `List.</trans> <trans data-src="Len()`. ">Len()`. </trans> <trans data-src="Since you cannot take the address of a map element, you cannot convert it to call `*List.">Since you cannot take the address of a map element, you cannot convert it to call `*List.</trans> <trans data-src="Append()`. ">Append()`. </trans> <trans data-src="The same applies to `interface`:">The same applies to `interface`:</trans> <trans data-src="```go">```go</trans> <trans data-src="fmt.">fmt.</trans> <trans data-src="Println(m["list1"].Len()) // ok">Println(m["list1"].Len()) // ok</trans> <trans data-src="m["list1"].">m["list1"].</trans> <trans data-src="Append(42) // bad, cannot call the pointer method Append on List">Append(42) // bad, cannot call the pointer method Append on List</trans> <trans data-src="i.(List).">i.(List).</trans> <trans data-src="Len() // ok">Len() // ok</trans> <trans data-src="i.(List).">i.(List).</trans> <trans data-src="Append() // bad, cannot call the pointer method Append on List">Append() // bad, cannot call the pointer method Append on List</trans> <trans data-src="```">```</trans> <trans data-src="# What Do Auto-Generated Pointer Receivers Do"># What Do Auto-Generated Pointer Receivers Do</trans> <trans data-src="If the auto-generated pointer receiver's function body is the same as the value receiver, can I modify the object's value through the pointer? ">If the auto-generated pointer receiver's function body is the same as the value receiver, can I modify the object's value through the pointer? </trans> <trans data-src="No. In fact, the pointer receiver calls the value receiver and passes arguments by value.">No. In fact, the pointer receiver calls the value receiver and passes arguments by value.</trans> <trans data-src="When using `dlv debug main.go` to debug `main.">When using `dlv debug main.go` to debug `main.</trans> <trans data-src="(*List).">(*List).</trans> <trans data-src="Len`, I found that it doesn't stop at this function breakpoint. ">Len`, I found that it doesn't stop at this function breakpoint. </trans> <trans data-src="Reviewing the previous code, `pl.Len()` may have been converted to `(*pl).">Reviewing the previous code, `pl.Len()` may have been converted to `(*pl).</trans> <trans data-src="Len()`, which caused it to use the value receiver. ">Len()`, which caused it to use the value receiver. </trans> <trans data-src="Therefore, it is necessary to forcefully use the pointer receiver:">Therefore, it is necessary to forcefully use the pointer receiver:</trans> <trans data-src="```go">```go</trans> <trans data-src="l := List{}">l := List{}</trans> <trans data-src="pl := &List{}">pl := &List{}</trans> <trans data-src="// List only implements `Len`">// List only implements `Len`</trans> <trans data-src="l.Append(42) // how does Go find `Append`?">l.Append(42) // how does Go find `Append`?</trans> <trans data-src="// (&l).">// (&l).</trans> <trans data-src="Append(42)">Append(42)</trans> <trans data-src="l.Len() // gets 1">l.Len() // gets 1</trans> <trans data-src="// *List implements `Append` explicitly, `Len` implicitly">// *List implements `Append` explicitly, `Len` implicitly</trans> <trans data-src="pl.Append(6)">pl.Append(6)</trans> <trans data-src="pl.Len() // gets 1">pl.Len() // gets 1</trans> <trans data-src="// Forcefully call `func(l *List) Len()`">// Forcefully call `func(l *List) Len()`</trans> <trans data-src="(*List).">(*List).</trans> <trans data-src="Len(pl) // gets 1">Len(pl) // gets 1</trans> <trans data-src="```">```</trans> <trans data-src="It is confirmed that `main.">It is confirmed that `main.</trans> <trans data-src="(*List).">(*List).</trans> <trans data-src="Len` internally calls `main.">Len` internally calls `main.</trans> <trans data-src="List.">List.</trans> <trans data-src="Len`.">Len`.</trans> <trans data-src="!">!</trans> <trans data-src="[](">[](</trans> <trans data-src="http://static.lo-li.net/images/2023/10/2023-10-20_19-44.png">http://static.lo-li.net/images/2023/10/2023-10-20_19-44.png</trans> <trans data-src=")">)</trans> <trans data-src="!">!</trans> <trans data-src="[](">[](</trans> <trans data-src="http://static.lo-li.net/images/2023/10/2023-10-20_19-45.png">http://static.lo-li.net/images/2023/10/2023-10-20_19-45.png</trans> <trans data-src=")">)</trans> ]]> zero https://lo-li.net/1420-1420.html#comments https://lo-li.net/feed/1420-1420.html https://lo-li.net/1417-1417.html https://lo-li.net/1417-1417.html Wed, 16 Aug 2023 08:00:00 +0000 rin <trans data-src="「基于锁的并发控制」与「多版本并发控制」是实现事务隔离级别的两种不同思路。">"Lock based concurrency control" and "Multi version concurrency control" are two different ideas to achieve transaction isolation level.</trans> <trans data-src="在两阶段锁中，事务分为获取锁的**增长阶段**和释放锁的**收缩阶段**。">In two-phase locks, transactions are divided into the * * growth phase * * of acquiring locks and the * * contraction phase * * of releasing locks.</trans> <trans data-src="在不同的阶段中通过设置不同的规则和限制可以实现不同的隔离级别。">Different isolation levels can be achieved by setting different rules and restrictions in different stages.</trans> <trans data-src="例如：">For example:</trans> <trans data-src="1. 读取数据时是否需要锁？">1. Is a lock required when reading data?</trans> <trans data-src="需要什么类型的锁？">What type of lock is required?</trans> <trans data-src="2. 什么时候释放锁？">2. When will the lock be released?</trans> <trans data-src="不同的隔离级别下，事务修改数据时都需要X锁，并在事务结束时释放。">Under different isolation levels, X locks are required when a transaction modifies data and are released at the end of the transaction.</trans> <trans data-src="这将保证两个写事务之间不会产生**脏写**的问题，这种问题在数据库中是不允许的。">This will ensure that the * * dirty write * * problem does not occur between two write transactions. This problem is not allowed in the database.</trans> <trans data-src="因此在不同隔离级别下都可能会用到X锁，但S锁不一定。">Therefore, the X lock may be used under different isolation levels, but the S lock is not necessarily used.</trans> <trans data-src="---">---</trans> <trans data-src="**READ UNCOMMITTED**">**READ UNCOMMITTED**</trans> <trans data-src="1. 事务读数据时不需要S锁，只需要在写数据时获取X锁。">1. The transaction does not need the S lock when reading data, but only needs to obtain the X lock when writing data.</trans> <trans data-src="这样当前事务的读操作就不会被其他事务的X锁阻塞；">In this way, the read operation of the current transaction will not be blocked by the X lock of other transactions;</trans> <trans data-src="2. 事务结束时释放X锁。">2. Release the X lock when the transaction ends.</trans> <trans data-src="释放X锁事务则进入收缩阶段。">Releasing the X lock transaction will enter the shrink phase.</trans> <trans data-src="由于读操作不会被阻塞，可以随时读到别的事务修改的数据，因此存在**脏读**问题。">Since the read operation will not be blocked and the data modified by other transactions can be read at any time, the problem of * * dirty read * * exists.</trans> <trans data-src="---">---</trans> <trans data-src="**READ COMMITTED**">**READ COMMITTED**</trans> <trans data-src="1. 当前事务读数据时需要S锁，以阻塞之后其他事务对数据的修改。">1. When the current transaction reads data, it needs an S lock to block the modification of data by other transactions.</trans> <trans data-src="同样，当其他事务先获取了X锁并修改数据时，当前事务对S锁的获取将被阻塞，直到其他事务的X锁释放才能读到数据。">Similarly, when other transactions first acquire the X lock and modify the data, the acquisition of the S lock by the current transaction will be blocked, and the data cannot be read until the X lock of other transactions is released.</trans> <trans data-src="2. 事务结束时释放X锁，释放X锁事务则进入收缩阶段。">2. Release the X lock when the transaction ends, and the X lock release transaction enters the shrink phase.</trans> <trans data-src="释放S锁不改变事务的阶段，因此可以随时释放（？）">Releasing the S lock does not change the transaction phase, so it can be released at any time (?)</trans> <trans data-src="READ COMMITTED解决了脏读问题：S锁会被X锁阻塞+事务结束时才释放X锁=只能读到提交/回滚的数据。">READ COMMITTED solves the dirty read problem: the S lock will be blocked by the X lock+the X lock will be released at the end of the transaction=only committed/rolled back data can be read.</trans> <trans data-src="但是没有解决不可重复读的问题：当前事务读完数据之后可以释放S锁，这时其他事务可以修改相应的数据并提交，当前事务再次读取时将得到不同的数据，即**不可重复读**问题。">However, the problem of non repeatable reading has not been solved: the S lock can be released after the current transaction has read the data. At this time, other transactions can modify the corresponding data and submit it. When the current transaction reads again, it will get different data, that is, the problem of * * non repeatable reading * *.</trans> <trans data-src="---">---</trans> <trans data-src="**REPEATABLE READ**">**REPEATABLE READ**</trans> <trans data-src="1. 与READ COMMITTED相同">1. Same as READ COMMITTED</trans> <trans data-src="2. 事务结束时释放X锁与S锁。">2. Release the X lock and the S lock at the end of the transaction.</trans> <trans data-src="事务进入收缩阶段。">The transaction enters the shrink phase.</trans> <trans data-src="由于S锁也会被保留到事务结束，因此其他事务无法修改相应的数据，当前事务中多次读取得到的也是同样的数据。">Since the S lock is also retained until the end of the transaction, other transactions cannot modify the corresponding data. The same data is obtained from multiple reads in the current transaction.</trans> <trans data-src="| | S锁 | X锁 |">|| S lock | X lock|</trans> <trans data-src="| --- | ------ | --- |">| --- | ------ | --- |</trans> <trans data-src="| RU | N/A | 结束时释放 |">|RU | N/A | Release at the end|</trans> <trans data-src="| RC | 读后释放 | 结束时释放 |">|RC | Release after reading | Release at the end|</trans> <trans data-src="| RR | 结束时释放 | 结束时释放 |">|RR | Release at the end | Release at the end|</trans> ]]> zero https://lo-li.net/1417-1417.html#comments https://lo-li.net/feed/1417-1417.html https://lo-li.net/1415-1415.html https://lo-li.net/1415-1415.html Sat, 20 May 2023 04:12:00 +0000 rin <trans data-src="1. `ExecutorContext *exec_ctx` 是什么？">1. What is' ExecutorContext * exec_ctx '?</trans> <trans data-src="2. 如何根据plan中的table_name找到要seq_scan的table？">2. How to find the table to seq_scan according to the table_name in the plan?</trans> <trans data-src="（or table_heap?）">（or table_heap?）</trans> <trans data-src="1. 查找到catalog.h中有关于table_name的信息">1. Find the information about table_name in catalog. h</trans> <trans data-src="2. The Catalog is a non-persistent catalog that is designed for use by executors within the DBMS execution engine. ">2. The Catalog is a non-persistent catalog that is designed for use by executors within the DBMS execution engine. </trans> <trans data-src="It handles table creation, **table lookup**, index creation, and index lookup.">It handles table creation, **table lookup**, index creation, and index lookup.</trans> <trans data-src="3. 查到`ExecutorContext`中包含了catalog，所以应该可以从`exec_ctx_`中获得table">3. It is found that the 'ExecutorContext' contains a catalog, so you can get the table from 'exec_ctx_'</trans> <trans data-src="## insert">## insert</trans> <trans data-src="3. 参考projection_executor写了insert_exector的构造函数及init、next">3. The constructor, init and next of insert_exector are written by referring to project_exector</trans> <trans data-src="1. 使用InsertTuple插入时，需要TupleMeta和Tuple，后者可以从child_executor->Next中获取，前者呢？——">1. When inserting with InsertTuple, TupleMeta and Tuple are required. The latter can be obtained from child_executor ->Next. What about the former——</trans> <trans data-src="只需手动设置TupleMeta的那三个字段">Just manually set the three fields of TupleMeta</trans> <trans data-src="2. 需要通过\*tuple返回插入的数量，如何构造这个Tuple？">2. The number of inserts needs to be returned through * tuple. How to construct this tuple?</trans> <trans data-src="构造tuple时也需要对应的schema，这个从何而来？——">When constructing tuples, the corresponding schema is also required. Where does this come from——</trans> <trans data-src="tuple需要一个vector\<Value> ，这个Value可以通过ValueFactory::GetIntegerValue()构造，而schema已经由planner传过来了，即output_schema，代表这个sql输出的schema是什么样">The tuple needs a vector <Value>, which can be constructed through ValueFactory:: GetIntegerValue(), and the schema has been transferred from the planner, that is, output_schema, which represents the schema output by the sql</trans> <trans data-src="3. 按照迭代器模型（volcano模型）的思想，我觉得在单次调用insert_executor->Next()的时候，在该executor内部应该也只应该调用一次child_executor->Next()，直到它返回false时我再返回false。">3. According to the idea of the iterator model (volcano model), I think that when insert_executor ->Next() is called once, child_executor ->Next() should be called only once inside the executor, and I will return false until it returns false.</trans> <trans data-src="但是在调用者（execution_engine.h:PollExecutor()）的代码中，它每一次执行我的Next时，都会往最终的result_set中插入一次tuple，这会导致该语句输出的结果中有多个row">But in the code of the caller (execution_engine. h: PollExecutor()), every time it executes My Next, it will insert a tuple into the final result_set, which will result in multiple rows in the output result of the statement</trans> <trans data-src="```">```</trans> <trans data-src="<main>:8"><main>:8</trans> <trans data-src="insert into t1 values (0, 'Emoji', 10), (1, 'EmojiEmoji', 11), (2, 'EmojiEmojiEmoji', 12), (3, 'EmojiEmojiEmojiEmoji', 13), (4, 'EmojiEmojiEmojiEmojiEmoji', 14);">insert into t1 values (0, 'Emoji', 10), (1, 'EmojiEmoji', 11), (2, 'EmojiEmojiEmoji', 12), (3, 'EmojiEmojiEmojiEmoji', 13), (4, 'EmojiEmojiEmojiEmojiEmoji', 14);</trans> <trans data-src="--- YOUR RESULT ---">--- YOUR RESULT ---</trans> <trans data-src="1 ">one</trans> <trans data-src="2 ">two</trans> <trans data-src="3 ">three</trans> <trans data-src="4 ">four</trans> <trans data-src="5 ">five</trans> <trans data-src="--- EXPECTED RESULT ---">--- EXPECTED RESULT ---</trans> <trans data-src="5">five</trans> <trans data-src="```">```</trans> <trans data-src="因此我一次性在Next()中使用循环将child_executor中产生的所有tuples处理完">So I use a loop in Next() to process all tuples generated in child_executor</trans> <trans data-src="---">---</trans> <trans data-src="在insert后，还需要插入index。">After inserting, you need to insert the index.</trans> <trans data-src="从`catalog->GetTableIndexes()`可以获得该table所有的index。">All indexes of the table can be obtained from 'catalog ->GetTableIndexes()'.</trans> <trans data-src="但是每个index覆盖的字段也不一样，无脑将新插入的这个tuple原样往index里插会导致segmentfault，要如何根据特定index schema去insert新的index？">However, the fields covered by each index are different, and mindless insertion of the newly inserted tuple into the index will result in a segmentfault. How do you insert a new index according to a specific index schema?</trans> <trans data-src="可以根据`index_info->key_scheme_`获得这个index的scheme，然后又根据这个table的scheme进行对应，选择需要的column生成key tuple。">The scheme of this index can be obtained according to 'index_info ->key_scheme_', and then corresponding to the scheme of this table. Select the required column to generate a key tuple.</trans> <trans data-src="在tuple.h中已经实现了`Tuple::KeyFromTuple()`可以直接使用。">'Tuple:: KeyFromTuple()' has been implemented in tuple. h and can be used directly.</trans> <trans data-src="## delete">## delete</trans> <trans data-src="4. 在delete_executor中同样使用循环处理所有的tuples，在TupleMeta中修改删除标记。">4. Repeat all tuples in delete_executor, and modify the deletion mark in TupleMeta.</trans> <trans data-src="在seq_search_executor->Next()中对于已被标记删除的tuple，应该忽略它，而不是立刻返回false，因为可能还有别的tuples要输出">In seq_search_executor ->Next(), the tuple that has been marked for deletion should be ignored instead of returning false immediately, because there may be other tuples to output</trans> <trans data-src="## update">## update</trans> <trans data-src="6. 在update_executor中，检查测试样例`explain update t1 set v3 = 445 where v1 >= 3;`">6. In update_executor, check the test sample ` explain update t1 set v3=445 where v1>=3`</trans> <trans data-src="的结果为">The result of is</trans> <trans data-src="```">```</trans> <trans data-src="=== BINDER ===">=== BINDER ===</trans> <trans data-src="BoundUpdate {">BoundUpdate {</trans> <trans data-src="table=BoundBaseTableRef { table=t1, oid=22 },">table=BoundBaseTableRef { table=t1, oid=22 },</trans> <trans data-src="filter_expr=(t1.v1>=3),">filter_expr=(t1.v1>=3),</trans> <trans data-src="target_expr=[(t1.v3, 445)],">target_expr=[(t1.v3, 445)],</trans> <trans data-src="}">}</trans> <trans data-src="=== PLANNER ===">=== PLANNER ===</trans> <trans data-src="Update { table_oid=22, target_exprs=[#0.0, #0.1, 445] } | (__bustub_internal.update_rows:INTEGER)">Update { table_oid=22, target_exprs=[#0.0, #0.1, 445] } | (__bustub_internal.update_rows:INTEGER)</trans> <trans data-src="Filter { predicate=(#0.0>=3) } | (t1.v1:INTEGER, t1.v2:VARCHAR, t1.v3:INTEGER)">Filter { predicate=(#0.0>=3) } | (t1.v1:INTEGER, t1.v2:VARCHAR, t1.v3:INTEGER)</trans> <trans data-src="SeqScan { table=t1 } | (t1.v1:INTEGER, t1.v2:VARCHAR, t1.v3:INTEGER)">SeqScan { table=t1 } | (t1.v1:INTEGER, t1.v2:VARCHAR, t1.v3:INTEGER)</trans> <trans data-src="=== OPTIMIZER ===">=== OPTIMIZER ===</trans> <trans data-src="Update { table_oid=22, target_exprs=[#0.0, #0.1, 445] } | (__bustub_internal.update_rows:INTEGER)">Update { table_oid=22, target_exprs=[#0.0, #0.1, 445] } | (__bustub_internal.update_rows:INTEGER)</trans> <trans data-src="SeqScan { table=t1, filter=(#0.0>=3) } | (t1.v1:INTEGER, t1.v2:VARCHAR, t1.v3:INTEGER)">SeqScan { table=t1, filter=(#0.0>=3) } | (t1.v1:INTEGER, t1.v2:VARCHAR, t1.v3:INTEGER)</trans> <trans data-src="```">```</trans> <trans data-src="对应的，代码中的child_executor即Filter，向update_executor提供需要更新的tuples。">Correspondingly, the child_executor in the code is the Filter, which provides update_executor with tuples that need to be updated.</trans> <trans data-src="然后新值存储在plan中的plan_->target_expressions_中。">Then the new value is stored in plan_ ->target_expressions_ in the plan.</trans> <trans data-src="即`target_exprs=[#0.0, #0.1, 445]`">That is, ` target_exprs=[# 0.0, # 0.1, 445]`</trans> <trans data-src="经过plan_->target_expressions_->Evaluate()后可以得到各列实际的值：`[3,EmojiEmojiEmojiEmoji,445]`">After plan_ ->target_expressions_ ->Evaluate(), the actual values of each column can be obtained: ` [3, EmojiEmojiEmojiEmojiEmoji, 445]`</trans> <trans data-src="```">```</trans> <trans data-src="update t1 set v3 = 445 where v1 >= 3;">update t1 set v3 = 445 where v1 >= 3;</trans> <trans data-src="2023-05-19 18:47:41 [update_executor.cpp:40:Next] DEBUG - Update from (3, EmojiEmojiEmojiEmoji, 13) Tuple size is 41">2023-05-19 18:47:41 [update_executor.cpp:40:Next] DEBUG - Update from (3, EmojiEmojiEmojiEmoji, 13) Tuple size is 41</trans> <trans data-src="2023-05-19 18:47:41 [update_executor.cpp:41:Next] DEBUG - To">2023-05-19 18:47:41 [update_executor.cpp:41:Next] DEBUG - To</trans> <trans data-src="2023-05-19 18:47:41 [update_executor.cpp:43:Next] DEBUG - Type: 4 Val: #0.0 Evaluated Val:3">2023-05-19 18:47:41 [update_executor.cpp:43:Next] DEBUG - Type: 4 Val: #0.0 Evaluated Val:3</trans> <trans data-src="2023-05-19 18:47:41 [update_executor.cpp:43:Next] DEBUG - Type: 7 Val: #0.1 Evaluated Val:EmojiEmojiEmojiEmoji">2023-05-19 18:47:41 [update_executor.cpp:43:Next] DEBUG - Type: 7 Val: #0.1 Evaluated Val:EmojiEmojiEmojiEmoji</trans> <trans data-src="2023-05-19 18:47:41 [update_executor.cpp:43:Next] DEBUG - Type: 4 Val: 445 Evaluated Val:445">2023-05-19 18:47:41 [update_executor.cpp:43:Next] DEBUG - Type: 4 Val: 445 Evaluated Val:445</trans> <trans data-src="```">```</trans> <trans data-src="## index_scan">## index_scan</trans> <trans data-src="在初始化BPlusTreeIndexIteratorForTwoIntegerColumn（IndexIterator）时，出现链接错误，找不到IndexIterator，即使对特定的那几个类型进行了explicit instantiation也不行，原因仅仅是因为这里使用了无参的构造函数，但是在index_iterator.h中没有定义，补上定义即可。">When initializing the BPlusTreeIndexIterator ForTwoIntegerColumn (IndexIterator), a link error occurred, and the IndexIterator could not be found, even if explicit instantiation was performed for specific types. The reason is that the construction function without parameters is used here, but it is not defined in index_iterator. h, so it is sufficient to supplement the definition.</trans> <trans data-src="## agg">## agg</trans> <trans data-src="首先根据注释，给aggregation_executor.h添加成员`SimpleAggregationHashTable aht_;`">First, add members to aggregation_executor. h 'SimpleAggregationHashTable aht_`</trans> <trans data-src="和`SimpleAggregationHashTable::Iterator aht_iterator_;`，">And 'SimpleAggregationHashTable:: Iterator aht_iterator_;',</trans> <trans data-src="并在构造函数上初始化。">And initialize on the constructor.</trans> <trans data-src="1. `SimpleAggregationHashTable`是什么？——">1. What is' SimpleAggregationHashTable '——</trans> <trans data-src="是一个`AggregateKey->AggregateValue`的hashtable">It is a hashtable of 'AggregateKey ->AggregateValue'</trans> <trans data-src="2. `AggregateKey`代表“ a key in an aggregation operation”，包含一个`std::vector<Value> group_bys_;`。">2. 'AggregateKey' stands for "a key in an aggregation operation", including a 'std:: vector<Value>group_bys_;'.</trans> <trans data-src="这个key应该与aggregate的columns有关。">This key should be related to the columns of aggregate.</trans> <trans data-src="3. `AggregateValue`里有一个`std::vector<Value> aggregates_;`，">3. There is a 'std:: vector<Value>aggregates_;' in 'AggregateValue',</trans> <trans data-src="应该是aggregate后的值。">It should be the value after aggregate.</trans> <trans data-src="1. 但是aggregate 函数如`CountStarAggregate, CountAggregate, SumAggregate, MinAggregate, MaxAggregate`这些也只产生一个值，或许vector里存了多个group产生的值？——">1. But aggregate functions such as' CountStarAggregate, CountAggregate, SumAggregate, MinAggregate, MaxAggregate 'also produce only one value. Maybe there are values generated by multiple groups stored in vector——</trans> <trans data-src="不是，vector里存的是不同聚集函数产生的值，第i个元素值代表`agg_types_[i]`这个类型的聚集函数">No, what is stored in vector is the value generated by different aggregation functions. The value of the ith element represents the 'agg_types_ [i]' aggregation function of this type</trans> <trans data-src="2. 在`aggregation_executor->Next()`中，像其他task一样，从child获取一个tuple然后进行处理。">2. In 'aggregation_executor ->Next()', like other tasks, get a tuple from the child and process it.</trans> <trans data-src="处理过程大概是构造AggregateKey和AggregateValue然后添加到某处">The process is to construct AggregateKey and AggregateValue and then add them somewhere</trans> <trans data-src="1. 查看`aggregation_executor.h`，其中有`MakeAggregateKey(),MakeAggregateValue(),aht_.">1. View 'aggregation_executor. h', where 'MakeAggregateKey(), MakeAggregateValue(), aht_</trans> <trans data-src="InsertCombine`几个函数。">InsertCombine ` Several functions.</trans> <trans data-src="构造Key的这个函数从plan_中获得**group_by_的expr**，使用evaluate求出keys；">The function to construct a key obtains * * expr * * of group_by_ from plan_, and uses evaluate to calculate keys;</trans> <trans data-src="构造Value的函数从plan_中获得**aggregate的expr**，使用evalutae求出values。">The function to construct Value obtains * * aggregate expr * * from plan_, and uses evalutae to calculate values.</trans> <trans data-src="2. 以第二个样例`insert into t1 values (-99999), (99999), (0), (1), (2), (3); ">2. Use the second example 'insert into t1 values (- 999999), (99999), (0), (1), (2), (3);</trans> <trans data-src="select count(*), min(v1), max(v1), count(v1), sum(v1) from t1;`">select count(*), min(v1), max(v1), count(v1), sum(v1) from t1;`</trans> <trans data-src="为例，第一次Next返回-99999这个tuple，MakeAggregateValue会用`count,min,max,count,sum`这五个函数产生`1,-99999,-99999,-99999,-99999`这五个值">For example, the first time Next returns the tuple of - 99999, MakeAggregateValue will use the five functions of 'count, min, max, count, sum' to generate the five values of '1, - 99999, - 99999, - 99999, - 99999, - 99999'</trans> <trans data-src="3. 在`CombineAggregateValues()`中，对于这五个值，就需要根据对于`agg_expr`的类型(`agg_types_[i]`)进行聚合处理。">3. In 'CombineAggregateValues()', these five values need to be aggregated according to the type of 'agg_expr' ('agg_types_ [i]').</trans> <trans data-src="4. 注意区分`count(*), count(column)`，前者统计总行数，后者统计该列中非空的数量。">4. Pay attention to distinguish between 'count (*)' and 'count (column)'. The former counts the total number of rows, and the latter counts the number of non empty columns in the column.</trans> <trans data-src="对于空表，前者为0；">For empty tables, the former is 0;</trans> <trans data-src="对于空列或者该全为null的列，后者为null。">For the empty column or the all null column, the latter is null.</trans> <trans data-src="对于其他聚集函数来说也是，input是null时跳过处理">For other aggregate functions, skip processing when input is null</trans> <trans data-src="5. executor的返回值是group_by columns + aggregation columns">5. The return value of executor is group_by columns+aggregation columns</trans> <trans data-src="> The output schema consists of the group-by columns followed by the aggregation columns.">> The output schema consists of the group-by columns followed by the aggregation columns.</trans> <trans data-src="如果我还select了其他column，但是没有orderby它，会怎样？——">What if I also select other columns, but do not have orderby——</trans> <trans data-src="这种情况可以是不允许的，参考MySQL的`only_full_group_by`。">This situation is not allowed. Please refer to MySQL's' only_full_group_by '.</trans> <trans data-src="因此不用处理非聚集的值和非groupby的值">So you don't have to deal with non aggregated values and non groupby values</trans> <trans data-src="例如，`__mock_table_1.colA:INTEGER`是groupby columns，`agg#0:INTEGER, agg#1:INTEGER, agg#2:INTEGER`是aggregate column">For example, '__mock_table_1. colA: INTEGER' is group by columns, 'agg # 0: INTEGER, agg # 1: INTEGER, agg # 2: INTEGER' is aggregate column</trans> <trans data-src="```">```</trans> <trans data-src="EXPLAIN SELECT max(colA), colA, MIN(colB), max(colB) FROM __mock_table_1 GROUP BY colA;">EXPLAIN SELECT max(colA), colA, MIN(colB), max(colB) FROM __mock_table_1 GROUP BY colA;</trans> <trans data-src="Agg { types=[max, min, max], aggregates=[#0.0, #0.1, #0.1], group_by=[#0.0] } | (__mock_table_1.colA:INTEGER, agg#0:INTEGER, agg#1:INTEGER, agg#2:INTEGER)">Agg { types=[max, min, max], aggregates=[#0.0, #0.1, #0.1], group_by=[#0.0] } | (__mock_table_1.colA:INTEGER, agg#0:INTEGER, agg#1:INTEGER, agg#2:INTEGER)</trans> <trans data-src="```">```</trans> <trans data-src="---">---</trans> <trans data-src="注意当表为空的时候，child的next不会返回tuples，aht_.">Note that when the table is empty, the next child will not return tuples, aht_</trans> <trans data-src="InsertCombine()就不会执行。">InsertCombine() will not be executed.</trans> <trans data-src="1. 如果查询中没有groupby，此时agg_executor->Next()仍要返回一些默认值，如函数`GenerateInitialAggregateValue()`中所指定的。">1. If there is no groupby in the query, agg_executor ->Next() still needs to return some default values, such as those specified in the function 'GenerateInitialAggregateValue()'.</trans> <trans data-src="为了复用`GenerateInitialAggregateValue(), InsertCombine()`这两个函数，我在处理空表时，对于`plan_->aggregates_`中使用到的各聚集函数，均构造一个null值作为agg_val，调用InsertCombine试图插入到hashtable中，此时`InsertCombine()`会对hashtable设置初值，而`CombineAggregateValues()">In order to reuse the two functions' GenerateInitialAggregateValue() and InsertCombine() ', when I process empty tables, I construct a null value as the agg_val for each aggregation function used in' plan_ ->aggregates_ ', and call InsertCombine to try to insert it into the hashtable. At this time,' InsertCombine() 'will set the initial value for the hashtable, while' CombineAggregateValues()</trans> <trans data-src="`会忽略掉我构造的这些null值，不动初值。">`These null values constructed by me will be ignored and the initial value will not be changed.</trans> <trans data-src="但这些只是aggregate函数们的默认值，如果查询语句有group by，那么还要构造这些列的空值作为默认值。">However, these are only the default values of aggregate functions. If the query statement has group by, then null values of these columns should be constructed as the default values.</trans> <trans data-src="2. 查询中有groupby，不返回值">2. There is groupby in the query, and no value is returned</trans> <trans data-src="---">---</trans> <trans data-src="在测试`select v4, min(v1) + sum(v2) + max(v3), count(*) from t1 group by v4;`">In Test ` select v4, min (v1)+sum (v2)+max (v3), count (*) from t1 group by v4`</trans> <trans data-src="的时候，aggregate_executor->Next()中的executed_无法等于true，导致这个Next()被无限调用。">The executed_ in aggregate_executor ->Next() cannot be equal to true, which causes the Next() to be called infinitely.</trans> <trans data-src="原因是我在Next()中修改hashtable后做了多余的更新迭代器的操作`aht_iterator_ = aht_.">The reason is that after I modified the hashtable in Next(), I did redundant operations to update the iterator ` aht_iterator_=aht_</trans> <trans data-src="Begin();`">Begin();`</trans> <trans data-src="导致无法满足结束的条件。">The end condition cannot be met.</trans> <trans data-src="只需在首次更新hashtable之后更新begin迭代器即可，即`Init()`和`if(!aggregated_)`中。">Just update the begin iterator after updating the hashtable for the first time, that is, in 'Init()' and 'if (! Aggregated_)'.</trans> <trans data-src="（在首次更新之前，hashtable为空，Begin返回的是end，这不是想要的）">(Before the first update, hashtable is empty, and Begin returns end, which is not what you want.)</trans> ]]> zero https://lo-li.net/1415-1415.html#comments https://lo-li.net/feed/1415-1415.html https://lo-li.net/1410-1410.html https://lo-li.net/1410-1410.html Sun, 23 Apr 2023 09:22:00 +0000 rin <trans data-src="Codes: [b_plus_tree.cpp](">Codes: [b_plus_tree.cpp](</trans> <trans data-src="https://git.lo-li.net/rin/bustub/src/branch/master/src/storage/index/b_plus_tree.cpp">https://git.lo-li.net/rin/bustub/src/branch/master/src/storage/index/b_plus_tree.cpp</trans> <trans data-src=" "b_plus_tree.cpp")"> "b_plus_tree.cpp")</trans> <trans data-src="# Task1 B+Tree Pages "># Task1 B+Tree Pages </trans> <trans data-src="## Page types">## Page types</trans> <trans data-src="There are 4 types of headers (classes) named as `b_plus_*_page_.h`">There are 4 types of headers (classes) named as `b_plus_*_page_.h`</trans> <trans data-src="1. `b_plus_tree_page.h`">1. `b_plus_tree_page.h`</trans> <trans data-src="2. `b_plus_tree_header_page.h`">2. `b_plus_tree_header_page.h`</trans> <trans data-src="3. `b_plus_tree_internal_page.h`">3. `b_plus_tree_internal_page.h`</trans> <trans data-src="4. `b_plus_tree_leaf_page.h`">4. `b_plus_tree_leaf_page.h`</trans> <trans data-src="Only `internal_page` and `leaf_page` are inherited from the base class defined in `b_plus_tree_page`.">Only `internal_page` and `leaf_page` are inherited from the base class defined in `b_plus_tree_page`.</trans> <trans data-src="At first, I was confused by the words `RootPage` and `HeaderPage`. ">At first, I was confused by the words `RootPage` and `HeaderPage`. </trans> <trans data-src="In fact, `header_page` does not belong to the inheritance tree. ">In fact, `header_page` does not belong to the inheritance tree. </trans> <trans data-src="It stores the metadata of a `BPlusTree` object, which is `root_page_id` for now.">It stores the metadata of a `BPlusTree` object, which is `root_page_id` for now.</trans> <trans data-src="`header_page` always exists in an initialized `BPlusTree`. ">`header_page` always exists in an initialized `BPlusTree`. </trans> <trans data-src="But `root_page_id` may be `INVALID_PAGE_ID` at some time, meaning the tree is **empty** (tree exists but no data).">But `root_page_id` may be `INVALID_PAGE_ID` at some time, meaning the tree is **empty** (tree exists but no data).</trans> <trans data-src="---">---</trans> <trans data-src="## Page structure">## Page structure</trans> <trans data-src="Both 2 types of pages share the common member variables `page_type_`, `size_` and `max_size_` defined in `BPlusTreePage`.">Both 2 types of pages share the common member variables `page_type_`, `size_` and `max_size_` defined in `BPlusTreePage`.</trans> <trans data-src="But the data area `MappingType array_[0]` is defined in `leaf_page.h` and `internal_page.h` separately.">But the data area `MappingType array_[0]` is defined in `leaf_page.h` and `internal_page.h` separately.</trans> <trans data-src="This is because the array is a *Flexible array* and it must be placed at the end of an object. ">This is because the array is a *Flexible array* and it must be placed at the end of an object. </trans> <trans data-src="But in `leaf_page`, there is an extra member `next_page_id_` after common members. ">But in `leaf_page`, there is an extra member `next_page_id_` after common members. </trans> <trans data-src="The class structure is as below:">The class structure is as below:</trans> <trans data-src="```">```</trans> <trans data-src="|| page_type_ | size_ | max_size_ | next_page_id_ | array_....... ||">|| page_type_ | size_ | max_size_ | next_page_id_ | array_....... ||</trans> <trans data-src="|| page_type_ | size_ | max_size_ | array_....... ||">|| page_type_ | size_ | max_size_ | array_....... ||</trans> <trans data-src="```">```</trans> <trans data-src="In later codes, a pointer of `internal_page` will be `reinterpret_cast` to a point of `leaf_page`. ">In later codes, a pointer of `internal_page` will be `reinterpret_cast` to a point of `leaf_page`. </trans> <trans data-src="And `page_type_` will be accessed to check the type of this page.">And `page_type_` will be accessed to check the type of this page.</trans> <trans data-src="Due to the common memory structure in both pages' headers, this operation is safe.">Due to the common memory structure in both pages' headers, this operation is safe.</trans> <trans data-src="### Internal page">### Internal page</trans> <trans data-src="```">```</trans> <trans data-src="| KEY(0)+PAGE_ID(0) | KEY(1)+PAGE_ID(1) | KEY(2)+.... |">| KEY(0)+PAGE_ID(0) | KEY(1)+PAGE_ID(1) | KEY(2)+.... |</trans> <trans data-src="⬆">⬆</trans> <trans data-src="[INVALID]">[INVALID]</trans> <trans data-src="```">```</trans> <trans data-src="There are $$m+1$$ pairs of `<key, page_id_t>` in an internal page. ">There are $$m+1$$ pairs of `<key, page_id_t>` in an internal page. </trans> <trans data-src="The 0th pair has an invalid key. ">The 0th pair has an invalid key. </trans> <trans data-src="So an Internal Page stores **m** ordered keys and **m+1** child pointers. `">So an Internal Page stores **m** ordered keys and **m+1** child pointers. `</trans> <trans data-src="max_size_ == m+1`">max_size_ == m+1`</trans> <trans data-src="The assignment specification recommends:">The assignment specification recommends:</trans> <trans data-src="> split an internal node when number of values reaches `max_size` before insertion">> split an internal node when number of values reaches `max_size` before insertion</trans> <trans data-src="### Leaf page">### Leaf page</trans> <trans data-src="Every key in a leaf page is valid.">Every key in a leaf page is valid.</trans> <trans data-src="> split a leaf node when the number of values reaches `max_size` after insertion">> split a leaf node when the number of values reaches `max_size` after insertion</trans> <trans data-src="So in any stable situation, max_size_ < size_">So in any stable situation, max_size_ < size_</trans> ]]> zero https://lo-li.net/1410-1410.html#comments https://lo-li.net/feed/1410-1410.html https://lo-li.net/1409-1409.html https://lo-li.net/1409-1409.html Fri, 15 Oct 2021 07:37:00 +0000 rin <trans data-src="# Ch18"># Ch18</trans> <trans data-src="## 18.1 Exception handling">## 18.1 Exception handling</trans> <trans data-src="Exceptions: seperate problem detection from problem resolution">Exceptions: seperate problem detection from problem resolution</trans> <trans data-src="- Thrown expression & current call chain -> determine which handler">- Thrown expression & current call chain -> determine which handler</trans> <trans data-src="- if a dtor wants to throw exceptions, it should handle them locally, or the program will be terminated.">- if a dtor wants to throw exceptions, it should handle them locally, or the program will be terminated.</trans> <trans data-src="- When search for `catch`, the *first* matched one is selected, not the best one.">- When search for `catch`, the *first* matched one is selected, not the best one.</trans> <trans data-src="- Thus catch clauses with class types must be orderd from the *most* derived one to *least* one.">- Thus catch clauses with class types must be orderd from the *most* derived one to *least* one.</trans> <trans data-src="- Conversions (between exception and "a catch exception declaration") only allowed when: ">- Conversions (between exception and "a catch exception declaration") only allowed when: </trans> <trans data-src="1. from *non-const* to *const*">1. from *non-const* to *const*</trans> <trans data-src="2. from *derived* to *base*">2. from *derived* to *base*</trans> <trans data-src="3. *array*/*function* to *pointer*">3. *array*/*function* to *pointer*</trans> <trans data-src="### function `try` block">### function `try` block</trans> <trans data-src="- `try` is before `: [init list]`">- `try` is before `: [init list]`</trans> <trans data-src="- will catch exceptions both in *init list* and *ctor body*">- will catch exceptions both in *init list* and *ctor body*</trans> <trans data-src="- An *implict* `throw` will be there, thus we HAVE to catch again in the outter scope">- An *implict* `throw` will be there, thus we HAVE to catch again in the outter scope</trans> <trans data-src="- (thus it seems useless)">- (thus it seems useless)</trans> <trans data-src="```c++">```c++</trans> <trans data-src="// function try block in Class">// function try block in Class</trans> <trans data-src="struct A {">struct A {</trans> <trans data-src="A(int v) try : a(v) {">A(int v) try : a(v) {</trans> <trans data-src="throw exception();">throw exception();</trans> <trans data-src="} catch(exception &e) {">} catch(exception &e) {</trans> <trans data-src="cout << e.what() << endl;">cout << e.what() << endl;</trans> <trans data-src="// implicit "throw;" here">// implicit "throw;" here</trans> <trans data-src="}">}</trans> <trans data-src="int a;">int a;</trans> <trans data-src="};">};</trans> <trans data-src="// in ordinary function">// in ordinary function</trans> <trans data-src="void func() try { throw "ordinary func throws"; }">void func() try { throw "ordinary func throws"; }</trans> <trans data-src="catch(const char *s) { cout << s << endl; }">catch(const char *s) { cout << s << endl; }</trans> <trans data-src="// Notice: parameter here must be `const char*` to recieve the thrown c-str">// Notice: parameter here must be `const char*` to recieve the thrown c-str</trans> <trans data-src="// or there will be a runtime error (not a compile-time error)">// or there will be a runtime error (not a compile-time error)</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="func();">func();</trans> <trans data-src="// must handle the rethrown exception">// must handle the rethrown exception</trans> <trans data-src="try {">try {</trans> <trans data-src="A a(1);">A a(1);</trans> <trans data-src="} catch(exception &e) { cout << e.what() << endl; }">} catch(exception &e) { cout << e.what() << endl; }</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="## 18.2 Namespaces">## 18.2 Namespaces</trans> <trans data-src="1. `using` Declaration: `using std::cin`">1. `using` Declaration: `using std::cin`</trans> <trans data-src="2. `using` Directive: `using namespace std`">2. `using` Directive: `using namespace std`</trans> <trans data-src="- Inside a class can only `using` members of its (direct or not) *base class*:">- Inside a class can only `using` members of its (direct or not) *base class*:</trans> <trans data-src="```c++">```c++</trans> <trans data-src="using std::cout;">using std::cout;</trans> <trans data-src="struct A{ int v=0; };">struct A{ int v=0; };</trans> <trans data-src="struct B{">struct B{</trans> <trans data-src="int v = 1;">int v = 1;</trans> <trans data-src="// using std::cin; // ">// using std::cin; // </trans> <trans data-src="NO, not class">NO, not class</trans> <trans data-src="// using A::v; // ">// using A::v; // </trans> <trans data-src="NO, not base">NO, not base</trans> <trans data-src="// using namespace xxx; // ">// using namespace xxx; // </trans> <trans data-src="NO, for `using` Directive either">NO, for `using` Directive either</trans> <trans data-src="};">};</trans> <trans data-src="struct C: public B {">struct C: public B {</trans> <trans data-src="using B::v; // ">using B::v; // </trans> <trans data-src="OK `using` base class members">OK `using` base class members</trans> <trans data-src="C() { cout << v << '\n';} // 1">C() { cout << v << '\n';} // 1</trans> <trans data-src="};">};</trans> <trans data-src="```">```</trans> <trans data-src="## 18.3 Multiple and Virtual Inheritance ">## 18.3 Multiple and Virtual Inheritance </trans> <trans data-src="### 18.3.2 Conversion">### 18.3.2 Conversion</trans> <trans data-src="```c++">```c++</trans> <trans data-src="// D1 -> A,B">// D1 -> A,B</trans> <trans data-src="// D2 -> C -> A">// D2 -> C -> A</trans> <trans data-src="struct A {};">struct A {};</trans> <trans data-src="struct B {};">struct B {};</trans> <trans data-src="struct D1 : A,B {};">struct D1 : A,B {};</trans> <trans data-src="struct C : A{};">struct C : A{};</trans> <trans data-src="struct D2 : C {};">struct D2 : C {};</trans> <trans data-src="void func(A &a); // ">void func(A &a); // </trans> <trans data-src="func1">func1</trans> <trans data-src="void func(B &b); // ">void func(B &b); // </trans> <trans data-src="func2">func2</trans> <trans data-src="void func(C &c); // ">void func(C &c); // </trans> <trans data-src="func3">func3</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="D1 d1; ">D1 d1; </trans> <trans data-src="D2 d2;">D2 d2;</trans> <trans data-src="func(d1); // ">func(d1); // </trans> <trans data-src="Ambiguous between 1 & 2">Ambiguous between 1 & 2</trans> <trans data-src="func(d2); // ">func(d2); // </trans> <trans data-src="OK, 3, not 1">OK, 3, not 1</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> ]]> zero https://lo-li.net/1409-1409.html#comments https://lo-li.net/feed/1409-1409.html https://lo-li.net/1408-1408.html https://lo-li.net/1408-1408.html Thu, 14 Oct 2021 06:32:00 +0000 rin <trans data-src="# Ch15 OOP"># Ch15 OOP</trans> <trans data-src="## 15.1 An Overview">## 15.1 An Overview</trans> <trans data-src="OOP is based on 3 fundamental concepts:">OOP is based on 3 fundamental concepts:</trans> <trans data-src="1. **Data abstraction**: Separate interface from implementation">1. **Data abstraction**: Separate interface from implementation</trans> <trans data-src="2. **Inheritance**: Define classes that model the relationships among similar types.">2. **Inheritance**: Define classes that model the relationships among similar types.</trans> <trans data-src="3. **Dynamic binding**(run-time binding): Use objects(*virtual function*) while ignoring the details of thow they differ (through *pointers* or *references* to the base class).">3. **Dynamic binding**(run-time binding): Use objects(*virtual function*) while ignoring the details of thow they differ (through *pointers* or *references* to the base class).</trans> <trans data-src="Inheritance:">Inheritance:</trans> <trans data-src="- A derived class must declare each inherited menber function it intends to override.">- A derived class must declare each inherited menber function it intends to override.</trans> <trans data-src="- The access specifier in derivation list is *optional*, default value = `private` for `class`, `public` for `struct`">- The access specifier in derivation list is *optional*, default value = `private` for `class`, `public` for `struct`</trans> <trans data-src="- A derived class ctor initializes its *direct* base class only.">- A derived class ctor initializes its *direct* base class only.</trans> <trans data-src="- Base part and derived part in an object are not guranteed to be stored contiguosly.">- Base part and derived part in an object are not guranteed to be stored contiguosly.</trans> <trans data-src="## 15.3 Virtual Function">## 15.3 Virtual Function</trans> <trans data-src="Virtual function:">Virtual function:</trans> <trans data-src="- Root of an inheritance hierarchy almost define a virtual dtor `virtual ~dtor(){}`.">- Root of an inheritance hierarchy almost define a virtual dtor `virtual ~dtor(){}`.</trans> <trans data-src="- Any *nonstatic* member func (other than ctor) can be virtual">- Any *nonstatic* member func (other than ctor) can be virtual</trans> <trans data-src="- If a virtul func with default args is called, which version of args to use is denpent on the static type. ">- If a virtul func with default args is called, which version of args to use is denpent on the static type. </trans> <trans data-src="Thus, such functions should use same default args. P607">Thus, such functions should use same default args. P607</trans> <trans data-src="- Virtual func declared in base class is implicitly virtual in derived classed: ">- Virtual func declared in base class is implicitly virtual in derived classed: </trans> <trans data-src="```c++">```c++</trans> <trans data-src="// inside base class:">// inside base class:</trans> <trans data-src="virtual void func() {}">virtual void func() {}</trans> <trans data-src="// inside derived class:">// inside derived class:</trans> <trans data-src="void func() = 0 // omitting keyword virtual is OK">void func() = 0 // omitting keyword virtual is OK</trans> <trans data-src="```">```</trans> <trans data-src="---">---</trans> <trans data-src="## 15.4 Abstract Base Classes">## 15.4 Abstract Base Classes</trans> <trans data-src="- We can provide a difinition for a *pure virtual* function (outside the class). ">- We can provide a difinition for a *pure virtual* function (outside the class). </trans> <trans data-src="It is used to provide some common operations. ">It is used to provide some common operations. </trans> <trans data-src="[c++ - Defining pure virtual functions outside the class definition - Stack Overflow](">[c++ - Defining pure virtual functions outside the class definition - Stack Overflow](</trans> <trans data-src="https://stackoverflow.com/questions/29449492/defining-pure-virtual-functions-outside-the-class-definition">https://stackoverflow.com/questions/29449492/defining-pure-virtual-functions-outside-the-class-definition</trans> <trans data-src=")">)</trans> <trans data-src="```c++">```c++</trans> <trans data-src="// outside the class">// outside the class</trans> <trans data-src="void B::func() { /*common operations */}">void B::func() { /*common operations */}</trans> <trans data-src="void B::~B() { /* some cleaning up *}">void B::~B() { /* some cleaning up *}</trans> <trans data-src="```">```</trans> <trans data-src="- Abstruct base class defines an *interface*">- Abstruct base class defines an *interface*</trans> <trans data-src="- A derived class ctor initializes its *direct* base class only.">- A derived class ctor initializes its *direct* base class only.</trans> <trans data-src="--- ">--- </trans> <trans data-src="## 15.5 Access Control & Inheritance">## 15.5 Access Control & Inheritance</trans> <trans data-src="- Members and **friends** of a derived class can access this (derived) class's protected members. ">- Members and **friends** of a derived class can access this (derived) class's protected members. </trans> <trans data-src="But the friends can't access the members of base class.">But the friends can't access the members of base class.</trans> <trans data-src="- In fact, a derived type object has no special access to the protected *ordinary* base type object.">- In fact, a derived type object has no special access to the protected *ordinary* base type object.</trans> <trans data-src="``` c++">``` c++</trans> <trans data-src="class B {">class B {</trans> <trans data-src="protected:">protected:</trans> <trans data-src="int v;">int v;</trans> <trans data-src="};">};</trans> <trans data-src="class D : public B {">class D : public B {</trans> <trans data-src="friend void func(D&); // ">friend void func(D&); // </trans> <trans data-src="can access D's protected member D::v">can access D's protected member D::v</trans> <trans data-src="friend void func(B&); // ">friend void func(B&); // </trans> <trans data-src="can't access B's protected member B::v">can't access B's protected member B::v</trans> <trans data-src="void func(B& b){b.v=1;} // no direct access to ordinary object's v">void func(B& b){b.v=1;} // no direct access to ordinary object's v</trans> <trans data-src="void func() {v=1;} // OK ">void func() {v=1;} // OK </trans> <trans data-src="};">};</trans> <trans data-src="```">```</trans> <trans data-src="### Dervied-to-Base Conversion">### Dervied-to-Base Conversion</trans> <trans data-src="Accessibility depends on *who* is using the conversion and the *access specifier* in derivation.">Accessibility depends on *who* is using the conversion and the *access specifier* in derivation.</trans> <trans data-src="1. The User Code: public">1. The User Code: public</trans> <trans data-src="2. The Member func and Friend func of the derived class: `public`, `protected`, `private`==<-why private works== #what ">2. The Member func and Friend func of the derived class: `public`, `protected`, `private`==<-why private works== #what </trans> <trans data-src="3. The Member func and Friend func of the derived class of derived class: `public`, `protected`">3. The Member func and Friend func of the derived class of derived class: `public`, `protected`</trans> <trans data-src="```c++">```c++</trans> <trans data-src="class B { protected: int v = 1; };">class B { protected: int v = 1; };</trans> <trans data-src="class D :/*__what to fill_____*/ B {">class D :/*__what to fill_____*/ B {</trans> <trans data-src="void member_func() {">void member_func() {</trans> <trans data-src="D d;">D d;</trans> <trans data-src="// CASE#2: derived-to-base conversion in MEMBER FUNC & FRIENDS">// CASE#2: derived-to-base conversion in MEMBER FUNC & FRIENDS</trans> <trans data-src="B b = (B)d; // ">B b = (B)d; // </trans> <trans data-src="OK: public, protected, private">OK: public, protected, private</trans> <trans data-src="}">}</trans> <trans data-src="friend void friend_func(); // ">friend void friend_func(); // </trans> <trans data-src="CASE#2: same for the FRIENDS">CASE#2: same for the FRIENDS</trans> <trans data-src="};">};</trans> <trans data-src="class AnotherClass : protected D {">class AnotherClass : protected D {</trans> <trans data-src="void func() {">void func() {</trans> <trans data-src="D d;">D d;</trans> <trans data-src="// CASE#3: derived-to-base conversion in the Class derived from D">// CASE#3: derived-to-base conversion in the Class derived from D</trans> <trans data-src="B b = (B)d; // ">B b = (B)d; // </trans> <trans data-src="OK: public, protected (both for the D->B and AC->D inheritance)">OK: public, protected (both for the D->B and AC->D inheritance)</trans> <trans data-src="}">}</trans> <trans data-src="};">};</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="D d;">D d;</trans> <trans data-src="// CASE#1: derived-to-base conversion in USER CODE">// CASE#1: derived-to-base conversion in USER CODE</trans> <trans data-src="B b = (B)d; // ">B b = (B)d; // </trans> <trans data-src="OK: only public">OK: only public</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="---">---</trans> <trans data-src="## 15.6 Class Scope under Inheritance">## 15.6 Class Scope under Inheritance</trans> <trans data-src="- Name Lookup happens before Type check. ">- Name Lookup happens before Type check. </trans> <trans data-src="The base functions are hidden even if the functions in derived class have different paramete list.">The base functions are hidden even if the functions in derived class have different paramete list.</trans> <trans data-src="- Once override one of the (Base class's) overloaded functions, other overloaded functions will be hiden. ">- Once override one of the (Base class's) overloaded functions, other overloaded functions will be hiden. </trans> <trans data-src="Use `using` to bring all versions:">Use `using` to bring all versions:</trans> <trans data-src="https://stackoverflow.com/questions/888235/overriding-a-bases-overloaded-function-in-c">https://stackoverflow.com/questions/888235/overriding-a-bases-overloaded-function-in-c</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="struct B {">struct B {</trans> <trans data-src="virtual void a(int) { cout << "B::a(int)" << endl;};">virtual void a(int) { cout << "B::a(int)" << endl;};</trans> <trans data-src="virtual void a(int, int) { cout << "B::a(int,int)" << endl;};">virtual void a(int, int) { cout << "B::a(int,int)" << endl;};</trans> <trans data-src="};">};</trans> <trans data-src="struct D: public B {">struct D: public B {</trans> <trans data-src="void a(int) { cout << "D::a(int)" << endl;};">void a(int) { cout << "D::a(int)" << endl;};</trans> <trans data-src="void a(int,int,int){ cout << "D::a(int,int,int)" << endl;};;">void a(int,int,int){ cout << "D::a(int,int,int)" << endl;};;</trans> <trans data-src="using B::a; // ">using B::a; // </trans> <trans data-src="bring all overloded function from B">bring all overloded function from B</trans> <trans data-src="};">};</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="D d; ">D d; </trans> <trans data-src="int i = 0;">int i = 0;</trans> <trans data-src="d.a(i); // ">d.a(i); // </trans> <trans data-src="OK, D::a(int)">OK, D::a(int)</trans> <trans data-src="// d.a(i, i); // ">// d.a(i, i); // </trans> <trans data-src="NO matching function without `using`">NO matching function without `using`</trans> <trans data-src="d.B::a(i,i); // ">d.B::a(i,i); // </trans> <trans data-src="OK, B::a(int,int)">OK, B::a(int,int)</trans> <trans data-src="d.a(i, i, i); // ">d.a(i, i, i); // </trans> <trans data-src="OK, D::a(int,int,int)">OK, D::a(int,int,int)</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="---">---</trans> <trans data-src="## 15.7 Ctor and Copy Control">## 15.7 Ctor and Copy Control</trans> <trans data-src="- Use `using` to "inherit" ctors from a class's *direct* base class. ">- Use `using` to "inherit" ctors from a class's *direct* base class. </trans> <trans data-src="Compiler generates ctors with a same parameter list as the ctor in the base class.">Compiler generates ctors with a same parameter list as the ctor in the base class.</trans> <trans data-src="- Unlike `using` ordinary members, this doesn't change the ctors access level and propertirs(explict, constexpr)">- Unlike `using` ordinary members, this doesn't change the ctors access level and propertirs(explict, constexpr)</trans> <trans data-src="- Base ctors with default parameters are split into serveral ctors withou default parameters #what ">- Base ctors with default parameters are split into serveral ctors withou default parameters #what </trans> <trans data-src="- default copy, move ctors are not ingerited">- default copy, move ctors are not ingerited</trans> <trans data-src="- a class that only contains inherited ctors will have a synthesized default ctor.">- a class that only contains inherited ctors will have a synthesized default ctor.</trans> <trans data-src="-">-</trans> ]]> zero https://lo-li.net/1408-1408.html#comments https://lo-li.net/feed/1408-1408.html https://lo-li.net/1394-manacher-example.html https://lo-li.net/1394-manacher-example.html Sat, 18 Jul 2020 14:38:00 +0000 rin <trans data-src="[前坑](">[Front pit]（</trans> <trans data-src="https://lo-li.net/1311-manacher-%E7%AE%97%E6%B3%95%E6%B1%82%E6%9C%80%E9%95%BF%E5%9B%9E%E6%96%87%E5%AD%90%E4%B8%B2.html">https://lo-li.net/1311-manacher-%E7%AE%97%E6%B3%95%E6%B1%82%E6%9C%80%E9%95%BF%E5%9B%9E%E6%96%87%E5%AD%90%E4%B8%B2.html</trans> <trans data-src=")">)</trans> <trans data-src="!">!</trans> <trans data-src="[manacher2.png](">[manacher2.png](</trans> <trans data-src="https://static.lo-li.net/typecho/2020/07/2154660342.png">https://static.lo-li.net/typecho/2020/07/2154660342.png</trans> <trans data-src=")">)</trans> <trans data-src="符号说明：">Symbol description:</trans> <trans data-src="* `i`为字符串中的下标，`S`是预处理后的字符串">*'i' is the subscript in the string, and 'S' is the preprocessed string</trans> <trans data-src="* `P[i]`代表以`i`为中心（含）的地方，回文的半径长度。">*'P [i]' represents the radius length of palindrome where 'i' is the center (included).</trans> <trans data-src="例如`P[1]=1`意为以`'#'`为中心的最长回文子串为`"#"`，半径长度为1；">For example, 'P [1]=1' means that the longest palindrome substring centered on '#' is' # ', and the radius length is 1;</trans> <trans data-src="同样，`P[16]=4`意为以`'x'`为中心的最长回文子串`"#p#x#p#"`的半径`"#p#x"/"x#p#"`的长度4">Similarly, 'P [16]=4' means the length 4 of the radius' # p # x '/' x # p # 'of the longest palindrome substring' # p # x # p # 'centered on' x '</trans> <trans data-src="* `id`代表当前已知的最长回文子串的中点；`">*'id' represents the midpoint of the longest palindrome substring currently known`</trans> <trans data-src="mx`代表该子串的半径长度+1">Mx ` represents the radius length of the substring+1</trans> <trans data-src="* 带圈数字代表步骤">*Circled numbers represent steps</trans> <trans data-src="①、起始状态，`i=0,mx=0,id=0`">① , Start Status, ` i=0, mx=0, id=0`</trans> <trans data-src="此时`i=1 >= mx=0`，即此位置已经超过了已知的最长回文范围（因为才开始嘛），同时也能确定`P[1]=至少=1`。">At this time, 'i=1>=mx=0', that is, this position has exceeded the known longest palindrome range (because it just started). At the same time, it can be determined that 'P [1]=at least=1'.</trans> <trans data-src="因此现在需要以`i=1`为中心，从其半径范围外两边开始逐一比对。">So now we need to take 'i=1' as the center, and start the comparison one by one from both sides outside its radius.</trans> <trans data-src="（两边就是`i±P[i]`）">(The two sides are 'i ± P [i]')</trans> <trans data-src="发现`'$'≠'a'`，扩展不下去了便停止，更新`id=1,mx=id+P[id]=1+1=2`">If '$' ≠'a '' is found, the extension will stop and update 'id=1, mx=id+P [id]=1+1=2`</trans> <trans data-src="②、`i=2,mx=2,id=1`">②、`i=2,mx=2,id=1`</trans> <trans data-src="此时`i=2 >= mx=2`，同样超过了已知的最长回文范围（注意`mx`是边界+1），同理能确定`P[2]=至少=1`。">At this time, 'i=2>=mx=2', which also exceeds the known longest palindrome range (note that 'mx' is the boundary+1). Similarly, it can be determined that 'P [2]=at least=1'.</trans> <trans data-src="继续扩展发现`'#'='#'`，则`P[2]++`，再继续无法扩展`$≠b`。">If you continue to expand and find that '#'='#' ', then' P [2]++'will fail to expand' $≠ b '.</trans> <trans data-src="更新`id=2,mx=id+P[id]=2+2=4`">Update ` id=2, mx=id+P [id]=2+2=4`</trans> <trans data-src="③、`i=3,mx=4,id=2`">③、`i=3,mx=4,id=2`</trans> <trans data-src="此时`i < mx`了，说明`i`在**已知最长的回文子串（id=2的那个）**的势力范围内了。">At this time, 'i<mx' indicates that 'i' is within the sphere of influence of * * the longest palindrome string (the one with id=2) * *.</trans> <trans data-src="那么根据对称性，`i=3`在前面就有一个“分身”`j=2*id-i=1`">According to the symmetry, 'i=3' has a "avatar" in front of it ` j=2 * id-i=1`</trans> <trans data-src="现在想求的`P[i]`就和`P[j]`有一种关系：`P[i]`=**可能**=`P[j]`，那么此时以`i`为中心的回文子串最右的下标就**有可能**扩展到`i+P[i]-1`，例如此时：">The 'P [i]' you want to seek now has a relationship with 'P [j]': 'P [i]'=* * may * *='P [j]', then the right subscript of palindrome substring centered on 'i' will * * possibly * * extend to 'i+P [i] - 1', for example:</trans> <trans data-src="!">!</trans> <trans data-src="[manacher1.png](">[manacher1.png](</trans> <trans data-src="https://static.lo-li.net/typecho/2020/07/3248822752.png">https://static.lo-li.net/typecho/2020/07/3248822752.png</trans> <trans data-src=")">)</trans> <trans data-src="`i+P[i]-1=3+1-1=3 < mx=4`，`3`仍处在**能保证对称的<span style="background-color:#ffe699">势力范围内</span>**，那么上面的“可能”变成“一定”。">`I+P [i] - 1=3+1-1=3<mx=4 `, ` 3 ` is still within the scope of influence of * * to ensure symmetry<span style="background color: # ffe699"></span>* *, then the "may" above becomes "certain".</trans> <trans data-src="（当然现在串还太短效果不是很明显，可以参考后面的⑥；同时“不可能”的情况请参考文末）">(Of course, the current string is too short, and the effect is not obvious. Please refer to ⑥ below; in the case of "impossible", please refer to the end of the article.)</trans> <trans data-src="④、⑤同理">④ ⑤ Same reason</trans> <trans data-src="⑥、`i=6,mx=10,id=5`">⑥、`i=6,mx=10,id=5`</trans> <trans data-src="`P[6]=P[4]=2`，现在能从下标`6-2=4`和`6+2=8`的位置开始对比，而对称区域内的都不用再比了。">`P [6]=P [4]=2 `, now you can compare from the subscript '6-2=4' and '6+2=8', and no comparison is needed in the symmetric area.</trans> <trans data-src="所以就利用了已知的信息跳过了很多次对比。">So we use the known information to skip many comparisons.</trans> <trans data-src="然后`'b'≠'a'`停止，`6+2=8 < mx=10`，说明仍然处于最长的那个子串内部，所以不更新`mx,id`">Then ''b' ≠'a '' stops, '6+2=8<mx=10', indicating that it is still inside the longest substring, so 'mx, id' is not updated`</trans> <trans data-src="……">……</trans> <trans data-src="如此便能算出所有的`P[i]`并且能得到最长的长度。">In this way, all 'P [i]' can be calculated and the longest length can be obtained.</trans> <trans data-src="------------">------------</trans> <trans data-src="“不可能”的情况">"Impossible" situation</trans> <trans data-src="换一个例子">Another example</trans> <trans data-src="!">!</trans> <trans data-src="[manacher3.png](">[manacher3.png](</trans> <trans data-src="https://static.lo-li.net/typecho/2020/07/31183235.png">https://static.lo-li.net/typecho/2020/07/31183235.png</trans> <trans data-src=")">)</trans> <trans data-src="此时`i=11,id=8,mx=14`">At this time, ` i=11, id=8, mx=14`</trans> <trans data-src="根据预判，`P[11]=P[5]=5`。">According to the prediction, 'P [11]=P [5]=5'.</trans> <trans data-src="但是下标`11+5=16 >= mx=14`，预判超过了**能保证对称**的部分，于是剩余的部分`14,15`就要和`8,7`暴力对比。">But the subscript '11+5=16>=mx=14', the prediction exceeds the part that * * can guarantee symmetry * *, so the remaining part '14,15' will be compared with '8,7' violently.</trans> ]]> zero https://lo-li.net/1394-manacher-example.html#comments https://lo-li.net/feed/1394-manacher-example.html https://lo-li.net/1393-1393.html https://lo-li.net/1393-1393.html Wed, 01 Feb 2017 15:01:00 +0000 rin <trans data-src="# 题目描述">#Title description</trans> <trans data-src="一家工厂生产的产品以相同的高$$h$$，六种不同的长宽$$1\*1,2\*2,3\*3,4\*4,5\*5,6\*6$$包装。">The products produced by one factory are packaged with the same height of $$h $$and six different lengths and widths of $$1 * 1,2 * 2,3 * 3,4 * 4,5 * 5,6 * 6 $$.</trans> <trans data-src="送货时集装的箱子的高也为$$h$$，长宽为$$6*6$$。">At the time of delivery, the height of the container is $$h $$, and the length and width are $$6 * 6 $$.</trans> <trans data-src="根据每种尺寸的产品的个数求出最少需要多少箱子来装。">According to the number of products of each size, find out the minimum number of boxes to be packed.</trans> <trans data-src="# 输入">#Input</trans> <trans data-src="输入包含多组数据">Input contains multiple sets of data</trans> <trans data-src="每组数据为一行六个数，分别代表边长$$1$$到$$6$$产品的个数。">Each group of data consists of six numbers in a row, representing the number of products with side length from $$1 $$to $$6 $$.</trans> <trans data-src="输入以六个$$0$$结束。">Input ends with six $$0 $$.</trans> <trans data-src="# 输出">#Output</trans> <trans data-src="每组数据输出一行一个数，代表最少需用的箱子个数。">Each group of data outputs one number per line, representing the minimum number of boxes needed.</trans> <trans data-src="# 样例输入">#Sample Input</trans> <trans data-src="```">```</trans> <trans data-src="0 0 4 0 0 1 ">0 0 4 0 0 1 </trans> <trans data-src="7 5 1 0 0 0 ">7 5 1 0 0 0 </trans> <trans data-src="0 0 0 0 0 0 ">0 0 0 0 0 0 </trans> <trans data-src="```">```</trans> <trans data-src="# 样例输出">#Sample Output</trans> <trans data-src="```">```</trans> <trans data-src="2">two</trans> <trans data-src="1">one</trans> <trans data-src="```">```</trans> <trans data-src="---">---</trans> <trans data-src="<!--"><!--</trans> <trans data-src="more-->">more--></trans> <trans data-src="# 解">#Solution</trans> <trans data-src="贪心，先放大的，再用小的来塞。">Greedy, first magnify, and then plug the small ones.</trans> <trans data-src="## 大的">##Large</trans> <trans data-src="一个$$6\*6$$的产品就能塞满一个箱子">A $$6 * 6 $$product can fill a box</trans> <trans data-src="一个$$5\*5$$的产品也得占一个箱子，并空出$$12$$个$$1\*1$$的位置">A $$5 * 5 $$product must also occupy a box, and leave $$12 $$space for $$1 * 1 $$</trans> <trans data-src="一个$$4\*4$$的产品也得占一个箱子，并空出$$5$$个$$2\*2$$的位置（因为先大后小所以按$$2\*2$$数而不是$$1\*1$$）">A $$4 * 4 $$product must also occupy a box, and leave $$5 $$positions for $$2 * 2 $$(because it is first big and then small, the number is $2 * 2 $$instead of $$1 * 1 $$)</trans> <trans data-src="以上尺寸是箱子里同种只能放下一个的。">The above size is only one of the same type in the box.</trans> <trans data-src="**四个**$$3\*3$$的产品占一个箱子，如果凑不出$$4$$的倍数个，那么根据余数不同能剩出不同个数的更小空间。">**Four * * $$3 * 3 $$products occupy one box. If there are no multiples of $$4 $$, there will be less space for different numbers depending on the remainder.</trans> <trans data-src="余数为$$1$$时，剩出$$5$$个$$2\*2$$，$$7$$个$$1\*1$$">When the balance is $$$$$, $$5 $$$$$$$$$$$$$$$$$$$2 * $, $$7 $$$$$$$1 * 1$$</trans> <trans data-src="余数为$$2$$时，剩出$$3$$个$$2\*2$$，$$6$$个$$1\*1$$">When the balance is $$2 $$, there are $$3 $$pieces $$2 * 2 $$, $$6 $$pieces $$1 * 1$$</trans> <trans data-src="余数为$$3$$时，剩出$$1$$个$$2\*2$$，$$5$$个$$1\*1$$">When the balance is $$3 $$, there are $$1 $$pieces $$2 * 2 $$, $$5 $$pieces $$1 * 1$$</trans> <trans data-src="## 小的">##Small</trans> <trans data-src="以上大的装完之后，首先用空出来的装$$2\*2$$的产品。">After the above large products are installed, first use the empty ones to install $2 * 2 $$products.</trans> <trans data-src="如果仍然不够，那么就开新箱子，则又能空出一些$$1\*1$$的空间；">If it is still not enough, open a new box, and then some space of $1 * 1 $$can be vacated;</trans> <trans data-src="如果够了，就把没用完的剩余空间全部计入$$1\*1$$中。">If it is enough, all the unused space will be included in $$1 * 1 $$.</trans> <trans data-src="最后装$$1\*1$$的，同上，再有剩余的就空着了。">The last one with $1 * 1 $$is the same as above, and the rest will be empty.</trans> <trans data-src="## Code">## Code</trans> <trans data-src="```c++">```c++</trans> <trans data-src="//AC">//AC</trans> <trans data-src="//">//</trans> <trans data-src="http://poj.org/problem?id=1017">http://poj.org/problem?id=1017</trans> <trans data-src="//">//</trans> <trans data-src="https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=247">https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=247</trans> <trans data-src="//">//</trans> <trans data-src="http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1307">http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1307</trans> <trans data-src="#include <cstdio>">#include <cstdio></trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <string>">#include <string></trans> <trans data-src="#include <algorithm>">#include <algorithm></trans> <trans data-src="#include <vector>">#include <vector></trans> <trans data-src="#include <cstring>">#include <cstring></trans> <trans data-src="#include <cmath>">#include <cmath></trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="#define INF 0x3f3f3f3f">#define INF 0x3f3f3f3f</trans> <trans data-src="int a, b, c, d, e, f;// ">int a, b, c, d, e, f;// </trans> <trans data-src="6种边长">6 side lengths</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="#ifndef ONLINE_JUDGE">#ifndef ONLINE_JUDGE</trans> <trans data-src="freopen("in.txt", "r", stdin);">freopen("in.txt", "r", stdin);</trans> <trans data-src="#endif">#endif</trans> <trans data-src="ios::sync_with_stdio(0);">ios::sync_with_stdio(0);</trans> <trans data-src="cin.tie(0);">cin.tie(0);</trans> <trans data-src="int res = 0;">int res = 0;</trans> <trans data-src="while (cin >> a >> b >> c >> d >> e >> f && (a || b || c || d || e || f)) {">while (cin >> a >> b >> c >> d >> e >> f && (a || b || c || d || e || f)) {</trans> <trans data-src="int validA = 0, validB = 0;">int validA = 0, validB = 0;</trans> <trans data-src="res = f + e + d; // ">res = f + e + d; // </trans> <trans data-src="每个边长为4、5、6的必须装到一个新箱子里">Each side length of 4, 5 and 6 must be put into a new box</trans> <trans data-src="validA = 11 * e; // ">validA = 11 * e; // </trans> <trans data-src="边长为5的每装一个箱就空出11个边长为1的位子">11 seats with side length of 1 are available for each box with side length of 5</trans> <trans data-src="validB = 5 * d; // ">validB = 5 * d; // </trans> <trans data-src="边长为4的每装一个箱就空出5个边长为2的位子">Five seats with side length of 2 are available for each box with side length of 4</trans> <trans data-src="res += ceil((double)c / 4.0); // ">res += ceil((double)c / 4.0); // </trans> <trans data-src="装边长为3的箱子个数">Number of boxes with 3 sides</trans> <trans data-src="int toomanyC = c % 4; // ">int toomanyC = c % 4; // </trans> <trans data-src="最后一个用来装边长3的箱子里只装了几个3">The last box for side length 3 contains only a few 3</trans> <trans data-src="if (toomanyC == 1) { // 只装了1个，则能空出5个2，7个1">If (toomanyC==1) {//If only one is installed, five 2's and seven 1's can be vacated</trans> <trans data-src="validB += 5;">validB += 5;</trans> <trans data-src="validA += 7;">validA += 7;</trans> <trans data-src="}">}</trans> <trans data-src="else if (toomanyC == 2) {">else if (toomanyC == 2) {</trans> <trans data-src="validB += 3;">validB += 3;</trans> <trans data-src="validA += 6;">validA += 6;</trans> <trans data-src="}">}</trans> <trans data-src="else if (toomanyC == 3) {">else if (toomanyC == 3) {</trans> <trans data-src="validB += 1;">validB += 1;</trans> <trans data-src="validA += 5;">validA += 5;</trans> <trans data-src="}">}</trans> <trans data-src="if (b > validB) { // 如果能当前剩的2的位子不够，则看用完之后需不需要补箱子，并更新空出的1">If (b>validB)</trans> <trans data-src="b -= validB;">b -= validB;</trans> <trans data-src="validB = 0;">validB = 0;</trans> <trans data-src="res += ceil((double)b / 9.0);">res += ceil((double)b / 9.0);</trans> <trans data-src="int toomanyB = b % 9;">int toomanyB = b % 9;</trans> <trans data-src="validA += 36 - 4 * toomanyB; //">validA += 36 - 4 * toomanyB; //</trans> <trans data-src="剩余的都给1">Give 1 to the rest</trans> <trans data-src="validB = 0;">validB = 0;</trans> <trans data-src="}">}</trans> <trans data-src="else { //如果够装2，就都用掉。">Else {//If enough 2 are installed, they will all be used.</trans> <trans data-src="validB -= b;">validB -= b;</trans> <trans data-src="}">}</trans> <trans data-src="validA += validB * 2 * 2; //">validA += validB * 2 * 2; //</trans> <trans data-src="最后装1，把所有大小的空位都归入1">Finally, install 1, and put all the empty spaces into 1</trans> <trans data-src="validB = 0;">validB = 0;</trans> <trans data-src="a -= validA;">a -= validA;</trans> <trans data-src="if (a > 0) {">if (a > 0) {</trans> <trans data-src="res += ceil((double)a / 36.0);">res += ceil((double)a / 36.0);</trans> <trans data-src="}">}</trans> <trans data-src="cout << res << '\n';">cout << res << '\n';</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> ]]> eleven https://lo-li.net/1393-1393.html#comments https://lo-li.net/feed/1393-1393.html https://lo-li.net/1392-1392.html https://lo-li.net/1392-1392.html Thu, 15 Dec 2016 06:32:00 +0000 rin <trans data-src="~~这个灰名选手一直坚持他蓝名梦想~~">~~This grey player has always adhered to his dream of becoming a blue star~~</trans> <trans data-src="------------">------------</trans> <trans data-src="[A. Vladik and flights](">[A. Vladik and flights](</trans> <trans data-src="http://codeforces.com/problemset/problem/743/A">http://codeforces.com/problemset/problem/743/A</trans> <trans data-src=")">)</trans> <trans data-src="有$$n$$个机场，要从$$a$$飞到$$b$$">There are $$n $$airports to fly from $$a $$to $$b$$</trans> <trans data-src="每个机场有航空公司$$0$$或$$1$$，同航空公司机场间移动无费用，不同的之间为$$|ni-nj|$$，问从$$a$$到$$b$$最少花费是多少。">Each airport has an airline of $$0 $$or $$1 $$. There is no cost for moving between airports of the same airline. The difference is $$| ni nj | $$. Ask what the minimum cost is from $$a $$to $$b $$.</trans> <trans data-src="因为同公司无费用，所以如果$$a$$和$$b$$地相同的话就输出$$0$$；">Because there is no cost in the same company, $$0 $$will be output if $$a $$and $$b $$are the same;</trans> <trans data-src="如果不相同，那么从$$a$$一定能移动到一个地方，是$$0$$和$$1$$的交界，然后在交界换一家公司飞到b，花费是$$1$$">If they are not the same, then they must be able to move from $$a $$to a place where $$0 $$and $$1 $$meet, and then fly from another company at the junction to b at a cost of $$1$$</trans> <trans data-src="```c++">```c++</trans> <trans data-src="int main(){">int main(){</trans> <trans data-src="int n, a, b;">int n, a, b;</trans> <trans data-src="char aType, bType;">char aType, bType;</trans> <trans data-src="scanf("%d %d %d", &n, &a, &b);">scanf("%d %d %d", &n, &a, &b);</trans> <trans data-src="getchar();">getchar();</trans> <trans data-src="for (int i = 1; i <= n; i++) {">for (int i = 1; i <= n; i++) {</trans> <trans data-src="if (i == a) scanf("%c", &aType);">if (i == a) scanf("%c", &aType);</trans> <trans data-src="else if (i == b) scanf("%c", &bType);">else if (i == b) scanf("%c", &bType);</trans> <trans data-src="else scanf("%*c");">else scanf("%*c");</trans> <trans data-src="}">}</trans> <trans data-src="puts((aType == bType || a == b) ? ">puts((aType == bType || a == b) ? </trans> <trans data-src=""0" : "1");">"0" : "1");</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="------------">------------</trans> <trans data-src="[B. Chloe and the sequence](">[B. Chloe and the sequence](</trans> <trans data-src="http://codeforces.com/problemset/problem/743/B">http://codeforces.com/problemset/problem/743/B</trans> <trans data-src=")">)</trans> <trans data-src="初始有一个序列$$[1]$$">There is initially a sequence $$[1]$$</trans> <trans data-src="然后将它本身加到后面变成$$[1,1]$$">Then add it to the end to become $$[1,1]$$</trans> <trans data-src="再将还未使用的最小的正整数加到正中的位置$$[1,2,1]$$">Add the smallest unused positive integer to the middle position $$[1,2,1]$$</trans> <trans data-src="重复$$n-1$$次">Repeat $$n-1 $$times</trans> <trans data-src="问这之后第$$k$$个数字是啥">Ask what is the $$k $$number after this</trans> <trans data-src="由~~观察瞎猜脑洞~~，~~可以看出~~，这个序列代表从$$1$$到某个数，(二进制)从右数起第一个$$1$$的位置，比如">From~~to observe the brain hole~~,~~, we can see that~~, this sequence represents the position of the first $$$from the right to a certain number, such as</trans> <trans data-src="| 数（二进制） | 1的位置 |">|Number (binary) | 1 position|</trans> <trans data-src="| ------------ | ------------ |">| ------------ | ------------ |</trans> <trans data-src="| 1(1) | 1 |">| 1(1) | 1 |</trans> <trans data-src="| 2(10) | 2 |">| 2(10) | 2 |</trans> <trans data-src="|3(11)|1|">|3(11)|1|</trans> <trans data-src="|4(100)|3|">|4(100)|3|</trans> <trans data-src="|5(101)|1|">|5(101)|1|</trans> <trans data-src="|6(110)|2|">|6(110)|2|</trans> <trans data-src="|...|...|">|...|...|</trans> <trans data-src="那么第$$k$$位是啥，就是$$k$$的右起第一个$$1$$位置。">Then what is the $$k $$bit? It is the first $$$$from the right of $$k $$.</trans> <trans data-src="可以直接用glibc里的`__builtin_ffs()`函数">You can directly use the '__builtin_ffs()' function in glibc</trans> <trans data-src="考虑到$$k$$超`int`用其`long long`版本 ` __builtin_ffsll()`">Considering that $$k $$super 'int' uses its' long long 'version' __builtin_ffsll()`</trans> <trans data-src="```c++">```c++</trans> <trans data-src="int main(){">int main(){</trans> <trans data-src="long long k;">long long k;</trans> <trans data-src="scanf("%*lld %lld", &k);">scanf("%*lld %lld", &k);</trans> <trans data-src="printf("%d\n", __builtin_ffsll(k));">printf("%d\n", __builtin_ffsll(k));</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> ]]> zero https://lo-li.net/1392-1392.html#comments https://lo-li.net/feed/1392-1392.html https://lo-li.net/1391-1391.html https://lo-li.net/1391-1391.html Sun, 06 Nov 2016 04:48:00 +0000 rin Add '- D_STDC_FORMAT_MACROS' to support' PRId64` #Problem A Wres...]]> <trans data-src="[PDF版](">[PDF version]（</trans> <trans data-src="http://pan.baidu.com/s/1bpkkoTD">http://pan.baidu.com/s/1bpkkoTD</trans> <trans data-src=")">)</trans> <trans data-src="> 添加 `-D__STDC_FORMAT_MACROS`以支持`PRId64`">>Add '- D_STDC_FORMAT_MACROS' to support' PRId64`</trans> <trans data-src="#Problem A Wrestling Match">#Problem A Wrestling Match</trans> <trans data-src="##提交情况：170/434">##Submission: 170/434</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="本题做法比较随意，此处说两种：">The method of this question is quite casual. Here are two ways:</trans> <trans data-src="1. 读入数据，建好图以后，以每一个点为开始遍历的起始节点，搜索整个图，在搜索的过程中判断是否出现冲突">1. After reading data and building a graph, search the whole graph with each point as the starting node, and judge whether there is conflict in the process of searching</trans> <trans data-src="2. 用并查集维护题目中所谓『好选手』以及『坏选手』的关系，在建立并查集的过程中，就可判断冲突">2. Maintain the relationship between the so-called "good players" and "bad players" in the topic by using the combined search set. In the process of establishing and searching the set, conflicts can be judged</trans> <trans data-src="总的来说，第2种做法需要处理的特殊情况较少，并且计算量照第1种做法少，所以标程采用第2种做法。">In general, the second method needs to deal with fewer special cases, and the calculation amount is less according to the first method, so the second method is adopted for the scale.</trans> <trans data-src="<!--"><!--</trans> <trans data-src="more-->">more--></trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <assert.h>">#include <assert.h></trans> <trans data-src="#define Max_N 1005">#define Max_N 1005</trans> <trans data-src="#define Max_M 10005">#define Max_M 10005</trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="int8_t gb_no[Max_N];">int8_t gb_no[Max_N];</trans> <trans data-src="int32_t uset[Max_N];">int32_t uset[Max_N];</trans> <trans data-src="int32_t urel[Max_N];">int32_t urel[Max_N];</trans> <trans data-src="int8_t rmap[Max_N];">int8_t rmap[Max_N];</trans> <trans data-src="int32_t pair_rel[Max_M][2];">int32_t pair_rel[Max_M][2];</trans> <trans data-src="void init(int32_t n) {">void init(int32_t n) {</trans> <trans data-src="memset(gb_no, -1, sizeof(gb_no));">memset(gb_no, -1, sizeof(gb_no));</trans> <trans data-src="memset(urel, 0, sizeof(urel));">memset(urel, 0, sizeof(urel));</trans> <trans data-src="memset(rmap, 0, sizeof(rmap));">memset(rmap, 0, sizeof(rmap));</trans> <trans data-src="for (int32_t i = 1; i <= n; i++) {">for (int32_t i = 1; i <= n; i++) {</trans> <trans data-src="uset[i] = i;">uset[i] = i;</trans> <trans data-src="}">}</trans> <trans data-src="return ;">return ;</trans> <trans data-src="}">}</trans> <trans data-src="int32_t father(int32_t ind, int32_t &rel) {">int32_t father(int32_t ind, int32_t &rel) {</trans> <trans data-src="if (uset[ind] == ind) {">if (uset[ind] == ind) {</trans> <trans data-src="rel = 0;">rel = 0;</trans> <trans data-src="return ind;">return ind;</trans> <trans data-src="}">}</trans> <trans data-src="int relt, fa;">int relt, fa;</trans> <trans data-src="fa = father(uset[ind], relt);">fa = father(uset[ind], relt);</trans> <trans data-src="urel[ind] = relt ^ urel[ind];">urel[ind] = relt ^ urel[ind];</trans> <trans data-src="uset[ind] = fa;">uset[ind] = fa;</trans> <trans data-src="rel = urel[ind];">rel = urel[ind];</trans> <trans data-src="return fa;">return fa;</trans> <trans data-src="}">}</trans> <trans data-src="bool insert(int32_t a, int32_t b) {">bool insert(int32_t a, int32_t b) {</trans> <trans data-src="int32_t fa, fb, rela, relb, rel;">int32_t fa, fb, rela, relb, rel;</trans> <trans data-src="fa = father(a, rela);">fa = father(a, rela);</trans> <trans data-src="fb = father(b, relb);">fb = father(b, relb);</trans> <trans data-src="rel = rela ^ relb ^ 1;">rel = rela ^ relb ^ 1;</trans> <trans data-src="if (fa == fb && rel != 0) return false;">if (fa == fb && rel != 0) return false;</trans> <trans data-src="if (fa != fb) {">if (fa != fb) {</trans> <trans data-src="uset[fa] = fb;">uset[fa] = fb;</trans> <trans data-src="urel[fa] = rel;">urel[fa] = rel;</trans> <trans data-src="}">}</trans> <trans data-src="return true;">return true;</trans> <trans data-src="}">}</trans> <trans data-src="bool set_father_no(int32_t a) {">bool set_father_no(int32_t a) {</trans> <trans data-src="int32_t fa, rela;">int32_t fa, rela;</trans> <trans data-src="fa = father(a, rela);">fa = father(a, rela);</trans> <trans data-src="if (gb_no[fa] >= 0 && gb_no[a] >= 0) {">if (gb_no[fa] >= 0 && gb_no[a] >= 0) {</trans> <trans data-src="return (gb_no[fa] ^ gb_no[a]) == rela;">return (gb_no[fa] ^ gb_no[a]) == rela;</trans> <trans data-src="} else if (gb_no[fa] == -1) {">} else if (gb_no[fa] == -1) {</trans> <trans data-src="gb_no[fa] = gb_no[a] ^ rela;">gb_no[fa] = gb_no[a] ^ rela;</trans> <trans data-src="}">}</trans> <trans data-src="return true;">return true;</trans> <trans data-src="}">}</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="int32_t n, m, x, y, ai, bi, t = 0;">int32_t n, m, x, y, ai, bi, t = 0;</trans> <trans data-src="bool flag;">bool flag;</trans> <trans data-src="while (scanf("%d%d%d%d", &n, &m, &x, &y) != ">while (scanf("%d%d%d%d", &n, &m, &x, &y) != </trans> <trans data-src="EOF) {">EOF) {</trans> <trans data-src="init(n); ">init(n); </trans> <trans data-src="flag = true;">flag = true;</trans> <trans data-src="assert(n > 1 && n <= 1000);">assert(n > 1 && n <= 1000);</trans> <trans data-src="assert(m >= 1 && m <= 10000);">assert(m >= 1 && m <= 10000);</trans> <trans data-src="assert(x + y <= n);">assert(x + y <= n);</trans> <trans data-src="for (int32_t i = 0; i < m; i++) {">for (int32_t i = 0; i < m; i++) {</trans> <trans data-src="scanf("%d%d", &ai, &bi);">scanf("%d%d", &ai, &bi);</trans> <trans data-src="assert(ai >= 1 && ai <= n);">assert(ai >= 1 && ai <= n);</trans> <trans data-src="assert(bi >= 1 && bi <= n);">assert(bi >= 1 && bi <= n);</trans> <trans data-src="assert(ai != bi);">assert(ai != bi);</trans> <trans data-src="rmap[ai] = rmap[bi] = 1;">rmap[ai] = rmap[bi] = 1;</trans> <trans data-src="flag = flag && insert(ai, bi);">flag = flag && insert(ai, bi);</trans> <trans data-src="}">}</trans> <trans data-src="for (int32_t i = 0; i < x; i++) {">for (int32_t i = 0; i < x; i++) {</trans> <trans data-src="scanf("%d", &ai);">scanf("%d", &ai);</trans> <trans data-src="assert(ai >= 1 && ai <= n);">assert(ai >= 1 && ai <= n);</trans> <trans data-src="if (gb_no[ai] != -1 && gb_no[ai] != 1) flag = false;">if (gb_no[ai] != -1 && gb_no[ai] != 1) flag = false;</trans> <trans data-src="gb_no[ai] = 1;">gb_no[ai] = 1;</trans> <trans data-src="flag = flag && set_father_no(ai);">flag = flag && set_father_no(ai);</trans> <trans data-src="}">}</trans> <trans data-src="for (int32_t i = 0; i < y; i++) {">for (int32_t i = 0; i < y; i++) {</trans> <trans data-src="scanf("%d", &ai);">scanf("%d", &ai);</trans> <trans data-src="assert(ai >= 1 && ai <= n);">assert(ai >= 1 && ai <= n);</trans> <trans data-src="if (gb_no[ai] != -1 && gb_no[ai] != 0) flag = false;">if (gb_no[ai] != -1 && gb_no[ai] != 0) flag = false;</trans> <trans data-src="gb_no[ai] = 0;">gb_no[ai] = 0;</trans> <trans data-src="flag = flag && set_father_no(ai);">flag = flag && set_father_no(ai);</trans> <trans data-src="}">}</trans> <trans data-src="for (int32_t i = 1; i <= n; i++) {">for (int32_t i = 1; i <= n; i++) {</trans> <trans data-src="flag = flag && (rmap[i] != 0 || gb_no[i] != -1);">flag = flag && (rmap[i] != 0 || gb_no[i] != -1);</trans> <trans data-src="}">}</trans> <trans data-src="printf("%s\n", flag ? "YES" : "NO");">printf("%s\n", flag ? "YES" : "NO");</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem B Regular Number">#Problem B Regular Number</trans> <trans data-src="##提交状况：20/104">##Submission status: 20/104</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="经典的shift-and算法可以搞定问题，会了shift-and算法以后，就需要注意以下事项了：">The classic shift and algorithm can solve the problem. After you know the shift and algorithm, you need to pay attention to the following matters:</trans> <trans data-src="1. 正则表达式的长度有1000，所以可以用一个Int64_t数字代表64位状态。">1. The length of the regular expression is 1000, so you can use an Int64_t number to represent the 64 bit status.</trans> <trans data-src="2. 做好映射表示，以免进行不必要的判断和计算，映射表示主要用来回答这个问题，正则表达式的第i个状态用状态数组的第几个数字的第几位表示。">2. Do a good job of mapping representation to avoid unnecessary judgment and calculation. The mapping representation is mainly used to answer this question. The i-th state of the regular expression is represented by the digit of the number of the state array.</trans> <trans data-src="具体的请看程序。">See the procedure for details.</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <stdint.h>">#include <stdint.h></trans> <trans data-src="#include <inttypes.h>">#include <inttypes.h></trans> <trans data-src="#define MAX_N 1005">#define MAX_N 1005</trans> <trans data-src="#define MAX_LEN 10000005">#define MAX_LEN 10000005</trans> <trans data-src="#define MAX_ARR_LEN ((MAX_N >> 6) + 5)">#define MAX_ARR_LEN ((MAX_N >> 6) + 5)</trans> <trans data-src="#define MASK 63">#define MASK 63</trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="#define MYPRID PRId64">#define MYPRID PRId64</trans> <trans data-src="typedef uint64_t myint;">typedef uint64_t myint;</trans> <trans data-src="myint num[10][MAX_ARR_LEN];">myint num[10][MAX_ARR_LEN];</trans> <trans data-src="myint ret_n[MAX_ARR_LEN];">myint ret_n[MAX_ARR_LEN];</trans> <trans data-src="myint ind_x_arr[MAX_N];">myint ind_x_arr[MAX_N];</trans> <trans data-src="myint ind_y_arr[MAX_N];">myint ind_y_arr[MAX_N];</trans> <trans data-src="char str[MAX_LEN];">char str[MAX_LEN];</trans> <trans data-src="void init(myint n) {">void init(myint n) {</trans> <trans data-src="memset(num, 0, sizeof(num));">memset(num, 0, sizeof(num));</trans> <trans data-src="memset(ret_n, 0, sizeof(ret_n));">memset(ret_n, 0, sizeof(ret_n));</trans> <trans data-src="for (myint i = 0; i < n; i++) {">for (myint i = 0; i < n; i++) {</trans> <trans data-src="ind_x_arr[i] = (i >> 6) + 1;">ind_x_arr[i] = (i >> 6) + 1;</trans> <trans data-src="ind_y_arr[i] = ((myint)1 << (i & MASK));">ind_y_arr[i] = ((myint)1 << (i & MASK));</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="inline void set_one(myint *arr, myint n) {">inline void set_one(myint *arr, myint n) {</trans> <trans data-src="arr[ind_x_arr[n]] |= ind_y_arr[n];">arr[ind_x_arr[n]] |= ind_y_arr[n];</trans> <trans data-src="}">}</trans> <trans data-src="inline bool seek_one(myint *arr, myint n) {">inline bool seek_one(myint *arr, myint n) {</trans> <trans data-src="return arr[ind_x_arr[n]] & ind_y_arr[n];">return arr[ind_x_arr[n]] & ind_y_arr[n];</trans> <trans data-src="}">}</trans> <trans data-src="inline void left_move_one(myint *arr, myint n) {">inline void left_move_one(myint *arr, myint n) {</trans> <trans data-src="for (myint i = n; i >= 1; i--) {">for (myint i = n; i >= 1; i--) {</trans> <trans data-src="arr[i] <<= 1;">arr[i] <<= 1;</trans> <trans data-src="arr[i] |= (!!(arr[i - 1] & 0x8000000000000000LL));">arr[i] |= (!!(arr[i - 1] & 0x8000000000000000LL));</trans> <trans data-src="}">}</trans> <trans data-src="set_one(arr, 0);">set_one(arr, 0);</trans> <trans data-src="}">}</trans> <trans data-src="inline void and_opt(myint *arr1, myint *arr2, myint n) {">inline void and_opt(myint *arr1, myint *arr2, myint n) {</trans> <trans data-src="for (myint i = 1; i<= n; i++) {">for (myint i = 1; i<= n; i++) {</trans> <trans data-src="arr1[i] &= arr2[i];">arr1[i] &= arr2[i];</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="myint n, ai, bi, len, l;">myint n, ai, bi, len, l;</trans> <trans data-src="char ch;">char ch;</trans> <trans data-src="scanf("%"MYPRID, &n);">scanf("%"MYPRID, &n);</trans> <trans data-src="init(n);">init(n);</trans> <trans data-src="for (myint i = 0; i < n; i++) {">for (myint i = 0; i < n; i++) {</trans> <trans data-src="scanf("%"MYPRID, &ai);">scanf("%"MYPRID, &ai);</trans> <trans data-src="for (myint j = 0; j < ai; j++) {">for (myint j = 0; j < ai; j++) {</trans> <trans data-src="scanf("%"MYPRID, &bi);">scanf("%"MYPRID, &bi);</trans> <trans data-src="set_one(num[bi], i);">set_one(num[bi], i);</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="scanf("%s", str);">scanf("%s", str);</trans> <trans data-src="len = strlen(str);">len = strlen(str);</trans> <trans data-src="l = (n >> 6) + (!!(n & MASK));">l = (n >> 6) + (!!(n & MASK));</trans> <trans data-src="for (myint i = 0; i < len; i++) {">for (myint i = 0; i < len; i++) {</trans> <trans data-src="left_move_one(ret_n, l);">left_move_one(ret_n, l);</trans> <trans data-src="and_opt(ret_n, num[str[i] - '0'], l);">and_opt(ret_n, num[str[i] - '0'], l);</trans> <trans data-src="if (seek_one(ret_n, n - 1)) {">if (seek_one(ret_n, n - 1)) {</trans> <trans data-src="ch = str[i + 1];">ch = str[i + 1];</trans> <trans data-src="str[i + 1] = '\0';">str[i + 1] = '\0';</trans> <trans data-src="printf("%s\n", str + i - n + 1);">printf("%s\n", str + i - n + 1);</trans> <trans data-src="str[i + 1] = ch;">str[i + 1] = ch;</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem C Game of Taking Stones">#Problem C Game of Taking Stones</trans> <trans data-src="##提交情况：13/93">##Submission: 13/93</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="题目是一个威佐夫博弈问题，可是数据范围太大原式在计算机种不是很容易解决问题，观察原威佐夫博弈的求解判别公式：">The problem is a Wizov game problem, but the data range is too large. The original formula is not easy to solve the problem in the computer type. Observe the solution formula of the original Wizov game:</trans> <trans data-src="```math">```math</trans> <trans data-src="A_{k}=\lfloor k\times \frac{1+\sqrt{5}}{2}\rfloor">A_{k}=\lfloor k\times \frac{1+\sqrt{5}}{2}\rfloor</trans> <trans data-src="```">```</trans> <trans data-src="```math">```math</trans> <trans data-src="B_{k}=A_{k}+k">B_{k}=A_{k}+k</trans> <trans data-src="```">```</trans> <trans data-src="两堆石子数两满足上式，即是一个『先手必败态』。">The number of two stones in two piles meets the above formula, that is, a "first hand will defeat" state.</trans> <trans data-src="观察公式中$$A_{k}$$部分的表示，与菲波那切数列通项公式有些关系。">Observe the expression of the $$A_ {k} $$part in the formula, which has some relationship with the general term formula of Fibonacci sequence.</trans> <trans data-src="而菲波那切数列第n项求解问题，使用『+/-』就可以搞定问题，所以标程的解决思路，是试图将上述公式转换成某种菲波那切数列问题的等价变换，这里只做提示，大家有兴趣可以自己进行详细推导，或找裁判讨论。">The solution of the nth term of the Fibonacci series can be solved by using "+/-", so the solution of the scale is to try to convert the above formula into an equivalent transformation of a Fibonacci series problem. Here is only a hint. If you are interested, you can make a detailed derivation or discuss with the referee.</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <time.h>">#include <time.h></trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="class BigInt {">class BigInt {</trans> <trans data-src="private :">private :</trans> <trans data-src="int flag, len, val[5000];">int flag, len, val[5000];</trans> <trans data-src="public :">public :</trans> <trans data-src="BigInt();">BigInt();</trans> <trans data-src="BigInt(const int &n);">BigInt(const int &n);</trans> <trans data-src="BigInt operator + (const int &n) const;">BigInt operator + (const int &n) const;</trans> <trans data-src="BigInt operator - (const int &n) const;">BigInt operator - (const int &n) const;</trans> <trans data-src="BigInt& operator = (const int &n);">BigInt& operator = (const int &n);</trans> <trans data-src="BigInt& operator = (const char* n);">BigInt& operator = (const char* n);</trans> <trans data-src="BigInt operator + (const BigInt &b) const;">BigInt operator + (const BigInt &b) const;</trans> <trans data-src="BigInt operator - (const BigInt &b) const;">BigInt operator - (const BigInt &b) const;</trans> <trans data-src="bool operator < (const BigInt &b) const;">bool operator < (const BigInt &b) const;</trans> <trans data-src="bool operator < (const int &n) const;">bool operator < (const int &n) const;</trans> <trans data-src="bool operator == (const BigInt &b) const;">bool operator == (const BigInt &b) const;</trans> <trans data-src="bool operator == (const int &n) const;">bool operator == (const int &n) const;</trans> <trans data-src="bool operator <= (const BigInt &b) const;">bool operator <= (const BigInt &b) const;</trans> <trans data-src="bool operator <= (const int &n) const;">bool operator <= (const int &n) const;</trans> <trans data-src="bool operator > (const BigInt &b) const;">bool operator > (const BigInt &b) const;</trans> <trans data-src="bool operator > (const int &n) const;">bool operator > (const int &n) const;</trans> <trans data-src="bool operator != ">bool operator != </trans> <trans data-src="(const BigInt &b) const;">(const BigInt &b) const;</trans> <trans data-src="bool operator != ">bool operator != </trans> <trans data-src="(const int &n) const;">(const int &n) const;</trans> <trans data-src="void Print();">void Print();</trans> <trans data-src="void Println();">void Println();</trans> <trans data-src="int getLen();">int getLen();</trans> <trans data-src="};">};</trans> <trans data-src="int BigInt::getLen() {">int BigInt::getLen() {</trans> <trans data-src="return this->len;">return this->len;</trans> <trans data-src="}">}</trans> <trans data-src="void BigInt::Print() {">void BigInt::Print() {</trans> <trans data-src="flag?">flag?</trans> <trans data-src="printf(""):printf("-");">printf(""):printf("-");</trans> <trans data-src="for (int i=this->len-1;i>=0;i--)">for (int i=this->len-1;i>=0;i--)</trans> <trans data-src="printf("%d",this->val[i]);">printf("%d",this->val[i]);</trans> <trans data-src="}">}</trans> <trans data-src="void BigInt::Println() {">void BigInt::Println() {</trans> <trans data-src="this->Print();">this->Print();</trans> <trans data-src="printf("\n");">printf("\n");</trans> <trans data-src="}">}</trans> <trans data-src="BigInt::BigInt() {">BigInt::BigInt() {</trans> <trans data-src="len=0;">len=0;</trans> <trans data-src="flag=true;">flag=true;</trans> <trans data-src="val[len]=0;">val[len]=0;</trans> <trans data-src="len++;">len++;</trans> <trans data-src="}">}</trans> <trans data-src="BigInt::BigInt(const int &n) {">BigInt::BigInt(const int &n) {</trans> <trans data-src="int temp(n);">int temp(n);</trans> <trans data-src="len=0;">len=0;</trans> <trans data-src="flag=(n>=0);">flag=(n>=0);</trans> <trans data-src="temp=temp>=0?">temp=temp>=0?</trans> <trans data-src="temp:-temp;">temp:-temp;</trans> <trans data-src="while (temp!=0)">while (temp!=0)</trans> <trans data-src="{">{</trans> <trans data-src="val[len]=temp%10;">val[len]=temp%10;</trans> <trans data-src="temp/=10;">temp/=10;</trans> <trans data-src="len++;">len++;</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="BigInt BigInt::operator + (const BigInt &b) const {">BigInt BigInt::operator + (const BigInt &b) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="BigInt temp1,temp2;">BigInt temp1,temp2;</trans> <trans data-src="temp1=*this;">temp1=*this;</trans> <trans data-src="temp2=b;">temp2=b;</trans> <trans data-src="temp1.flag=temp2.flag=true;">temp1.flag=temp2.flag=true;</trans> <trans data-src="if (this->flag&&!b.flag) {">if (this->flag&&!b.flag) {</trans> <trans data-src="temp=temp1-temp2;">temp=temp1-temp2;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="if (!this->flag&&b.flag) {">if (!this->flag&&b.flag) {</trans> <trans data-src="temp=temp2-temp1;">temp=temp2-temp1;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="temp.len=b.len>this->len?">temp.len=b.len>this->len?</trans> <trans data-src="b.len:this->len;">b.len:this->len;</trans> <trans data-src="for (int i=0;i<temp.len;i++) {">for (int i=0;i<temp.len;i++) {</trans> <trans data-src="if (i<b.len)">if (i<b.len)</trans> <trans data-src="temp.val[i]=b.val[i];">temp.val[i]=b.val[i];</trans> <trans data-src="else">else</trans> <trans data-src="temp.val[i]=0;">temp.val[i]=0;</trans> <trans data-src="if (i<this->len)">if (i<this->len)</trans> <trans data-src="temp.val[i]+=this->val[i];">temp.val[i]+=this->val[i];</trans> <trans data-src="}">}</trans> <trans data-src="for (int i=0;i<temp.len;i++)">for (int i=0;i<temp.len;i++)</trans> <trans data-src="if (temp.val[i]>=10) {">if (temp.val[i]>=10) {</trans> <trans data-src="if (i==temp.len-1) {">if (i==temp.len-1) {</trans> <trans data-src="temp.val[i+1]=1;">temp.val[i+1]=1;</trans> <trans data-src="temp.val[i]-=10;">temp.val[i]-=10;</trans> <trans data-src="temp.len++;">temp.len++;</trans> <trans data-src="}">}</trans> <trans data-src="else {">else {</trans> <trans data-src="temp.val[i+1]++;">temp.val[i+1]++;</trans> <trans data-src="temp.val[i]-=10;">temp.val[i]-=10;</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="temp.flag=this->flag;">temp.flag=this->flag;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="BigInt BigInt::operator + (const int &n) const {">BigInt BigInt::operator + (const int &n) const {</trans> <trans data-src="BigInt temp(n);">BigInt temp(n);</trans> <trans data-src="return (temp+*this);">return (temp+*this);</trans> <trans data-src="}">}</trans> <trans data-src="BigInt BigInt::operator - (const BigInt &b) const {">BigInt BigInt::operator - (const BigInt &b) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="BigInt temp1,temp2;">BigInt temp1,temp2;</trans> <trans data-src="temp1=*this;">temp1=*this;</trans> <trans data-src="temp2=b;">temp2=b;</trans> <trans data-src="temp1.flag=temp2.flag=true;">temp1.flag=temp2.flag=true;</trans> <trans data-src="if (this->flag&&!b.flag) {">if (this->flag&&!b.flag) {</trans> <trans data-src="temp=temp1+temp2;">temp=temp1+temp2;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="if (!this->flag&&b.flag) {">if (!this->flag&&b.flag) {</trans> <trans data-src="temp=temp1+temp2;">temp=temp1+temp2;</trans> <trans data-src="temp.flag=false;">temp.flag=false;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="if (!this->flag&&!b.flag) {">if (!this->flag&&!b.flag) {</trans> <trans data-src="temp1.flag=false;">temp1.flag=false;</trans> <trans data-src="temp=temp1+temp2;">temp=temp1+temp2;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="if (*this==b) {">if (*this==b) {</trans> <trans data-src="temp=0;">temp=0;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="if (*this<b) {">if (*this<b) {</trans> <trans data-src="temp=(b-(*this));">temp=(b-(*this));</trans> <trans data-src="temp.flag=false;">temp.flag=false;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="temp=*this;">temp=*this;</trans> <trans data-src="for (int i=0;i<b.len;i++)">for (int i=0;i<b.len;i++)</trans> <trans data-src="temp.val[i]=temp.val[i]-b.val[i];">temp.val[i]=temp.val[i]-b.val[i];</trans> <trans data-src="for (int i=0;i<temp.len;i++) {">for (int i=0;i<temp.len;i++) {</trans> <trans data-src="if (temp.val[i]<0) {">if (temp.val[i]<0) {</trans> <trans data-src="temp.val[i]+=10;">temp.val[i]+=10;</trans> <trans data-src="temp.val[i+1]-=1;">temp.val[i+1]-=1;</trans> <trans data-src="}">}</trans> <trans data-src="else if (i>=b.len) break;">else if (i>=b.len) break;</trans> <trans data-src="}">}</trans> <trans data-src="while (temp.val[temp.len-1]==0&&temp.len>1)">while (temp.val[temp.len-1]==0&&temp.len>1)</trans> <trans data-src="temp.len--;">temp.len--;</trans> <trans data-src="temp.flag=true;">temp.flag=true;</trans> <trans data-src="return temp;">return temp;</trans> <trans data-src="}">}</trans> <trans data-src="BigInt BigInt::operator - (const int &n) const {">BigInt BigInt::operator - (const int &n) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="temp=n;">temp=n;</trans> <trans data-src="return (*this-temp);">return (*this-temp);</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator < (const BigInt &b) const {">bool BigInt::operator < (const BigInt &b) const {</trans> <trans data-src="if (this->flag&&!b.flag) return false;">if (this->flag&&!b.flag) return false;</trans> <trans data-src="if (!this->flag&&b.flag) return true;">if (!this->flag&&b.flag) return true;</trans> <trans data-src="if (this->len<b.len) return true;">if (this->len<b.len) return true;</trans> <trans data-src="if (this->len>b.len) return false;">if (this->len>b.len) return false;</trans> <trans data-src="for (int i=this->len-1;i>=0;i--) {">for (int i=this->len-1;i>=0;i--) {</trans> <trans data-src="if (this->val[i]!=b.val[i]) {">if (this->val[i]!=b.val[i]) {</trans> <trans data-src="if (this->val[i]<b.val[i]) return this->flag;">if (this->val[i]<b.val[i]) return this->flag;</trans> <trans data-src="else return !">else return !</trans> <trans data-src="this->flag;">this->flag;</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="return false;">return false;</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator < (const int &n) const {">bool BigInt::operator < (const int &n) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="temp=n;">temp=n;</trans> <trans data-src="return (*this<temp);">return (*this<temp);</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator == (const BigInt &b) const {">bool BigInt::operator == (const BigInt &b) const {</trans> <trans data-src="if (*this<b) return false;">if (*this<b) return false;</trans> <trans data-src="if (b<*this) return false;">if (b<*this) return false;</trans> <trans data-src="return true;">return true;</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator == (const int &n) const {">bool BigInt::operator == (const int &n) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="temp=n;">temp=n;</trans> <trans data-src="return (*this==temp);">return (*this==temp);</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator <= (const BigInt &b) const {">bool BigInt::operator <= (const BigInt &b) const {</trans> <trans data-src="if ((*this<b)||(*this==b)) return true;">if ((*this<b)||(*this==b)) return true;</trans> <trans data-src="return false;">return false;</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator <= (const int &n) const {">bool BigInt::operator <= (const int &n) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="temp=n;">temp=n;</trans> <trans data-src="return (*this<=temp);">return (*this<=temp);</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator > (const BigInt &b) const {">bool BigInt::operator > (const BigInt &b) const {</trans> <trans data-src="return (b<*this);">return (b<*this);</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator > (const int &n) const {">bool BigInt::operator > (const int &n) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="temp=n;">temp=n;</trans> <trans data-src="return (temp<*this);">return (temp<*this);</trans> <trans data-src="}">}</trans> <trans data-src="BigInt& BigInt::operator = (const int &n) {">BigInt& BigInt::operator = (const int &n) {</trans> <trans data-src="int temp;">int temp;</trans> <trans data-src="temp=n;">temp=n;</trans> <trans data-src="len=0;">len=0;</trans> <trans data-src="flag=(n>=0);">flag=(n>=0);</trans> <trans data-src="temp=temp>=0?">temp=temp>=0?</trans> <trans data-src="temp:-temp;">temp:-temp;</trans> <trans data-src="while (temp!=0)">while (temp!=0)</trans> <trans data-src="{">{</trans> <trans data-src="val[len]=temp%10;">val[len]=temp%10;</trans> <trans data-src="temp/=10;">temp/=10;</trans> <trans data-src="len++;">len++;</trans> <trans data-src="}">}</trans> <trans data-src="if (len==0){val[0]=0;len=1;}">if (len==0){val[0]=0;len=1;}</trans> <trans data-src="return *this;">return *this;</trans> <trans data-src="}">}</trans> <trans data-src="BigInt& BigInt::operator = (const char* n) {">BigInt& BigInt::operator = (const char* n) {</trans> <trans data-src="int j=0;">int j=0;</trans> <trans data-src="int len=strlen(n);">int len=strlen(n);</trans> <trans data-src="for (int i=len-1;i>=0;i--)">for (int i=len-1;i>=0;i--)</trans> <trans data-src="{">{</trans> <trans data-src="this->val[j]=(n[i]-'0')%10;">this->val[j]=(n[i]-'0')%10;</trans> <trans data-src="j++;">j++;</trans> <trans data-src="}">}</trans> <trans data-src="this->len=j;">this->len=j;</trans> <trans data-src="return *this;">return *this;</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator != ">bool BigInt::operator != </trans> <trans data-src="(const BigInt &b) const {">(const BigInt &b) const {</trans> <trans data-src="if (*this<b||b<*this) return true;">if (*this<b||b<*this) return true;</trans> <trans data-src="return false;">return false;</trans> <trans data-src="}">}</trans> <trans data-src="bool BigInt::operator != ">bool BigInt::operator != </trans> <trans data-src="(const int &n) const {">(const int &n) const {</trans> <trans data-src="BigInt temp;">BigInt temp;</trans> <trans data-src="temp=n;">temp=n;</trans> <trans data-src="if (*this!=temp) return true;">if (*this!=temp) return true;</trans> <trans data-src="return false;">return false;</trans> <trans data-src="}">}</trans> <trans data-src="BigInt a[500];">BigInt a[500];</trans> <trans data-src="BigInt b[500];">BigInt b[500];</trans> <trans data-src="int main()">int main()</trans> <trans data-src="{">{</trans> <trans data-src="BigInt n,m;">BigInt n,m;</trans> <trans data-src="a[0]=a[2]=2;">a[0]=a[2]=2;</trans> <trans data-src="a[1]=a[3]=3;">a[1]=a[3]=3;</trans> <trans data-src="b[0]=b[1]=b[2]=b[3]=1;">b[0]=b[1]=b[2]=b[3]=1;</trans> <trans data-src="for (int i=4;i<=485;i++)">for (int i=4;i<=485;i++)</trans> <trans data-src="a[i]=a[i-1]+a[i-2];">a[i]=a[i-1]+a[i-2];</trans> <trans data-src="for (int i=4;i<=485;i++)">for (int i=4;i<=485;i++)</trans> <trans data-src="b[i]=b[i-1]+b[i-2];">b[i]=b[i-1]+b[i-2];</trans> <trans data-src="char s[100],w[100];">char s[100],w[100];</trans> <trans data-src="BigInt temp, we, ha;">BigInt temp, we, ha;</trans> <trans data-src="while (scanf("%s%s",s,w)!=">while (scanf("%s%s",s,w)!=</trans> <trans data-src="EOF)">EOF)</trans> <trans data-src="{">{</trans> <trans data-src="n=s; ">n=s; </trans> <trans data-src="m=w;">m=w;</trans> <trans data-src="if (n>m) {">if (n>m) {</trans> <trans data-src="temp=m;">temp=m;</trans> <trans data-src="m=n;">m=n;</trans> <trans data-src="n=temp;">n=temp;</trans> <trans data-src="}">}</trans> <trans data-src="we=0; ">we=0; </trans> <trans data-src="ha=m;">ha=m;</trans> <trans data-src="int j = -1;">int j = -1;</trans> <trans data-src="while (a[j+1] <= ha) {">while (a[j+1] <= ha) {</trans> <trans data-src="++j;">++j;</trans> <trans data-src="ha = ha - a[j];">ha = ha - a[j];</trans> <trans data-src="we = we + b[j];">we = we + b[j];</trans> <trans data-src="}">}</trans> <trans data-src="while (j >= 3 && ha != 0) {">while (j >= 3 && ha != 0) {</trans> <trans data-src="if (a[j] <= ha) {">if (a[j] <= ha) {</trans> <trans data-src="ha = ha - a[j];">ha = ha - a[j];</trans> <trans data-src="we = we + b[j];">we = we + b[j];</trans> <trans data-src="}">}</trans> <trans data-src="--j;">--j;</trans> <trans data-src="}">}</trans> <trans data-src="if (ha == 0 && n == (m - we))">if (ha == 0 && n == (m - we))</trans> <trans data-src="printf("0\n");">printf("0\n");</trans> <trans data-src="else">else</trans> <trans data-src="printf("1\n");">printf("1\n");</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem D A Simple Math Problem">#Problem D A Simple Math Problem</trans> <trans data-src="##提交情况：182/528">##Submission: 182/528</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="题目中给出$$x,y$$两数的和以及两个数的最小公倍数：">The title gives the sum of $$x, y $$and the least common multiple of the two numbers:</trans> <trans data-src="```math">```math</trans> <trans data-src="X+Y=a">X+Y=a</trans> <trans data-src="```">```</trans> <trans data-src="```math">```math</trans> <trans data-src="LeastCommonMultiple(X,Y)=b">LeastCommonMultiple(X,Y)=b</trans> <trans data-src="```">```</trans> <trans data-src="设$$X,Y$$的最大公约数为$$c$$，则可得如下式子：">If the maximum common divisor of $$X, Y $$is $$c $$, the following formula can be obtained:</trans> <trans data-src="```katex">```katex</trans> <trans data-src="\begin{array}{}">\begin{array}{}</trans> <trans data-src="(1):\space X=z_{1}\times c \\">(1):\space X=z_{1}\times c \\</trans> <trans data-src="(2):\space Y=z_{2}\times c \\">(2):\space Y=z_{2}\times c \\</trans> <trans data-src="(3):\space X+Y=(Z_{1}+Z_{2})\times c \\">(3):\space X+Y=(Z_{1}+Z_{2})\times c \\</trans> <trans data-src="(4):\space LeastCommonMultiple(X,Y)=z_{1}\times z_{2}\times c">(4):\space LeastCommonMultiple(X,Y)=z_{1}\times z_{2}\times c</trans> <trans data-src="\end{array}">\end{array}</trans> <trans data-src="```">```</trans> <trans data-src="-">-</trans> <trans data-src="因为$$\gcd(z_{1},z_{2})=1$$，所以$$\gcd((1),(2))=c$$，所以可得如下式子：">Because $$ gcd (z_ {1}, z_ {2})=1 $$, $$ gcd ((1), (2))=c $$, the following formula can be obtained:</trans> <trans data-src="```katex">```katex</trans> <trans data-src="\begin{array}{}">\begin{array}{}</trans> <trans data-src="z_{1}+z_{2}=\frac{(1)}{c} \\">z_{1}+z_{2}=\frac{(1)}{c} \\</trans> <trans data-src="z_{1}\times z_{2}=\frac{(2)}{c} \\">z_{1}\times z_{2}=\frac{(2)}{c} \\</trans> <trans data-src="(z_">(z_</trans> <trans data-src="{1}-z_">{1}-z_</trans> <trans data-src="{2})^{2}=(z_{1}+z_{2})^">{2})^{2}=(z_{1}+z_{2})^</trans> <trans data-src="{2}-4">{2}-4</trans> <trans data-src="\times z_{1}\times z_{2}">\times z_{1}\times z_{2}</trans> <trans data-src="\end{array}">\end{array}</trans> <trans data-src="```">```</trans> <trans data-src="-">-</trans> <trans data-src="从而可得$$z_">So we can get $$z_</trans> <trans data-src="{1}-z_">{1}-z_</trans> <trans data-src="{2}$$的值，得解。">{2} The value of $$is solved.</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <assert.h>">#include <assert.h></trans> <trans data-src="#include <math.h>">#include <math.h></trans> <trans data-src="#define NS_STR "No Solution"">#define NS_STR "No Solution"</trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="int32_t gcd(int32_t a, int32_t b) {">int32_t gcd(int32_t a, int32_t b) {</trans> <trans data-src="if (!b) return a;">if (!b) return a;</trans> <trans data-src="return gcd(b, a % b);">return gcd(b, a % b);</trans> <trans data-src="}">}</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="int32_t a, b, c, d, e, f, g, x, y;">int32_t a, b, c, d, e, f, g, x, y;</trans> <trans data-src="while (scanf("%d%d", &a, &b) != ">while (scanf("%d%d", &a, &b) != </trans> <trans data-src="EOF) {">EOF) {</trans> <trans data-src="assert(a <= 2 * 10000 && a >= 1);">assert(a <= 2 * 10000 && a >= 1);</trans> <trans data-src="assert(b <= 1000000000 && b >= 1);">assert(b <= 1000000000 && b >= 1);</trans> <trans data-src="c = gcd(a, b);">c = gcd(a, b);</trans> <trans data-src="d = a / c;">d = a / c;</trans> <trans data-src="e = b / c;">e = b / c;</trans> <trans data-src="f = d * d - 4 * e;">f = d * d - 4 * e;</trans> <trans data-src="if (f < 0) {">if (f < 0) {</trans> <trans data-src="printf("%s\n", NS_STR);">printf("%s\n", NS_STR);</trans> <trans data-src="continue;">continue;</trans> <trans data-src="}">}</trans> <trans data-src="g = (int32_t)sqrt(f);">g = (int32_t)sqrt(f);</trans> <trans data-src="if (g * g != f) {">if (g * g != f) {</trans> <trans data-src="printf("%s\n", NS_STR);">printf("%s\n", NS_STR);</trans> <trans data-src="continue;">continue;</trans> <trans data-src="}">}</trans> <trans data-src="g = -g;">g = -g;</trans> <trans data-src="x = (g + d) / 2 * c;">x = (g + d) / 2 * c;</trans> <trans data-src="y = a - x;">y = a - x;</trans> <trans data-src="assert(x > 0 && y > 0);">assert(x > 0 && y > 0);</trans> <trans data-src="printf("%d %d\n", x, y);">printf("%d %d\n", x, y);</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem E Aninteresting game">#Problem E Aninteresting game</trans> <trans data-src="##提交情况：29/134">##Submission: 29/134</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="本题是一道计数问题。">This problem is a counting problem.</trans> <trans data-src="1.第一个操作可以用前缀和的差来求解。">1. The first operation can be solved by the difference between prefix and.</trans> <trans data-src="添加完前$$x$$个数字，消耗$$\sum_{i=1}^">After adding the first $$x $$numbers, $$ sum_ {i=1} will be consumed^</trans> <trans data-src="{x}lowbit">{x}lowbit</trans> <trans data-src="(i)$$点体力。">(i) $$points of physical strength.</trans> <trans data-src="通过枚举lowbit可以降低求和复杂度至$$logx$$">Enumerating lowbit can reduce the sum complexity to $$logx$$</trans> <trans data-src="2.第二个操作求$$x$$被加入新集合的次数。">2. The second operation calculates the number of times $$x $$is added to the new set.</trans> <trans data-src="我们先考虑添加$$k$$时，$$[k-lowbit(k)+1, k-1]$$和$$k$$会被加入新集合。">When we first consider adding $$k $$, $$[k-lowbit (k)+1, k-1] $$and $$k $$will be added to the new set.</trans> <trans data-src="除去$$k$$，剩余的是$$k$$的最低非零位变成了0，更低的位**不全为0**的所有数字。">Excluding $$k $$, the remaining is all the numbers where the lowest non-zero bit of $$k $$becomes 0, and the lower bit * * is not all 0 * *.</trans> <trans data-src="反过来，先找到$$x$$的最低非零位，将某个比该位高的位置由0变成1得到$$k$$。">Conversely, first find the lowest non-zero bit of $$x $$, and change a position higher than this bit from 0 to 1 to get $$k $$.</trans> <trans data-src="添加$$k$$时，$$x$$会被加入新集合。">When you add $$k $$, $$x $$will be added to the new set.</trans> <trans data-src="这样的$$k$$的个数是：$$x$$二进制表示中比$$x$$最低非零位高的0的个数。">The number of such $$k $$is: the number of zeros higher than the lowest non-zero bit of $$x $$in the binary representation of $$x $$.</trans> <trans data-src="再加上$$x$$本身就得到结果。">Add $$x $$itself to get the result.</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <stdio.h>">#include <stdio.h></trans> <trans data-src="#include <string.h>">#include <string.h></trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <stdint.h>">#include <stdint.h></trans> <trans data-src="#include <inttypes.h>">#include <inttypes.h></trans> <trans data-src="#include <algorithm>">#include <algorithm></trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="typedef int64_t ll;">typedef int64_t ll;</trans> <trans data-src="ll n, l, r, q, a;">ll n, l, r, q, a;</trans> <trans data-src="ll Cal(ll x) {">ll Cal(ll x) {</trans> <trans data-src="ll ans = 0;">ll ans = 0;</trans> <trans data-src="for(int k = 0; (1ll<<k) <= x; ">for(int k = 0; (1ll<<k) <= x; </trans> <trans data-src="k++) {">k++) {</trans> <trans data-src="ans += ((x>>(k+1)) + !!">ans += ((x>>(k+1)) + !!</trans> <trans data-src="((1ll<<k) & x)) * (1ll<<k);">((1ll<<k) & x)) * (1ll<<k);</trans> <trans data-src="}">}</trans> <trans data-src="return ans;">return ans;</trans> <trans data-src="}">}</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="while(scanf("%" PRId64 "%" PRId64, &n, &q) != ">while(scanf("%" PRId64 "%" PRId64, &n, &q) != </trans> <trans data-src="EOF) {">EOF) {</trans> <trans data-src="while(q --) {">while(q --) {</trans> <trans data-src="scanf("%" PRId64, &a);">scanf("%" PRId64, &a);</trans> <trans data-src="if(a == 1) {">if(a == 1) {</trans> <trans data-src="scanf("%" PRId64 "%" PRId64, &l, &r);">scanf("%" PRId64 "%" PRId64, &l, &r);</trans> <trans data-src="printf("%" PRId64 "\n", Cal(r) - Cal(l-1));">printf("%" PRId64 "\n", Cal(r) - Cal(l-1));</trans> <trans data-src="}">}</trans> <trans data-src="else {">else {</trans> <trans data-src="scanf("%" PRId64, &l);">scanf("%" PRId64, &l);</trans> <trans data-src="ll ans = 1ll;">ll ans = 1ll;</trans> <trans data-src="l += l & (-l);">l += l & (-l);</trans> <trans data-src="while (l <= n) {">while (l <= n) {</trans> <trans data-src="++ans;">++ans;</trans> <trans data-src="l += l & (-l);">l += l & (-l);</trans> <trans data-src="}">}</trans> <trans data-src="printf("%" PRId64"\n", ans);">printf("%" PRId64"\n", ans);</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem F Detachment">#Problem F Detachment</trans> <trans data-src="##提交情况：150/428">##Submission: 150/428</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="题意相当于给定一个自然数$$x$$，让你给出一种拆分方式$$x=a_{1}+a_{2}\ldots (a_{i}\neq a_{j})$$，使得每个小部分的乘积$$s=a_{1}\times a_{2}\times \ldots $$最大">The meaning of the question is equivalent to given a natural number $$x $$, let you give a splitting method $$x=a_ {1}+a_ {2} ldots (a_ {i} neq a_ {j}) $$, so that the product of each small part $$s=a_ {1} times a_ {2} times ldots $$is the largest</trans> <trans data-src="对于使得$$s(s>4)$$最大的递增序列$$a_{1},a_{2}\ldots $$，有以下性质：">For the increasing sequence $$a_ {1}, a_ {2} ldots $$that makes $$s (s>4) $$the largest, it has the following properties:</trans> <trans data-src="1）$$a{i+1}\leq 2$$">1）$$a{i+1}\leq 2$$</trans> <trans data-src="2）最多有一个$$i$$，满足$$a_{i+1}-a_{i}=2$$">2) There can be at most one $$i $$, satisfying $$a_ {i+1} - a_ {i}=2$$</trans> <trans data-src="3）$$1< a_{1}\leq 3$$">3）$$1< a_{1}\leq 3$$</trans> <trans data-src="反证法证明上述结论，简证如下：">The counterevidence method proves the above conclusion, and the brief proof is as follows:</trans> <trans data-src="证明性质1。">Nature of proof 1.</trans> <trans data-src="假设存在$$i$$，满足$$a_{i+1}-a_{i}> 2$$，用$$a_{i+1}-1$$和$$a_{i}+1$$会得到更大的乘积，矛盾。">If $$i $$exists and $$a_ {i+1} - a_ {i}>2 $$is satisfied, using $$a_ {i+1} - 1 $$and $$a_ {i}+1 $$will result in a larger product and contradiction.</trans> <trans data-src="性质2。">Nature 2.</trans> <trans data-src="假设存在$$i< j$$，满足$$a_{i+1}-a_{i}=2$$，$$a_{j+1}-a_{j}> 2$$，用$$a_{j+1}-1$$和$$a_{i}+1$$代替$$a_{j+1}$$和$$a_{i}$$，会得到更大的乘积，矛盾。">Assuming that $$i<j $$exists, $$a_ {i+1} - a_ {i}=2 $$, $$a_ {j+1} - a_ {j}>2 $$, replace $$a_ {j+1} - 1 $$and $$a_ {i}+1 $$with $$a_ {i}+1 $$$$to get a larger product and contradiction.</trans> <trans data-src="性质3。">Nature 3.</trans> <trans data-src="如果$$a_{1}=1$$，那么它加到$$a_{i}(i>1)$$上去会得到更大的乘积。">If $$a_ {1}=1 $$, then adding it to $$a_ {i} (i>1) $$will result in a larger product.</trans> <trans data-src="矛盾！">Contradiction!</trans> <trans data-src="如果$$a_{1}=4$$，分两种情况考虑。">If $$a_ {1}=4 $$, consider two cases.</trans> <trans data-src="1）$$a_{2}=5=2+3,2\times 3\times 4>4\times 5$$，得到一个$$a_{1}=2$$的更优解。">1) $$a_ {2}=5=2+3,2 times 3 times 4>4 times 5 $$, and a better solution of $$a_ {1}=2 $$is obtained.</trans> <trans data-src="矛盾！">Contradiction!</trans> <trans data-src="2）$$a_{2}=6,4+6=2+3+5,2\times 3\times 5>4\times 6$$，得到一个$$a_{1}=2$$的更优解。">2) $$a_ {2}=6,4+6=2+3+5,2 times 3 times 5>4 times 6 $$, and a better solution of $$a_ {1}=2 $$is obtained.</trans> <trans data-src="矛盾！">Contradiction!</trans> <trans data-src="综上，解的结构是以下两种中的一种。">To sum up, the structure of the solution is one of the following two.</trans> <trans data-src="```katex">```katex</trans> <trans data-src="\begin{array}{}">\begin{array}{}</trans> <trans data-src="s=2\times 3\times \ldots \times (r-1)\times (r+1)\times \ldots \times n \\">s=2\times 3\times \ldots \times (r-1)\times (r+1)\times \ldots \times n \\</trans> <trans data-src="s=3\times \ldots \times (r-1)\times (r+1)\times \ldots \times n">s=3\times \ldots \times (r-1)\times (r+1)\times \ldots \times n</trans> <trans data-src="\end{array}">\end{array}</trans> <trans data-src="```">```</trans> <trans data-src="对于每一类最优解都是唯一确定$$r$$和$$n$$，所以找出一组猫足条件的$$r$$和$$n$$即可构造出最优解。">For each type of optimal solution, $$r $$and $$n $$are uniquely determined, so find a set of cat foot conditions $$r $$and $$n $$to construct the optimal solution.</trans> <trans data-src="观察可知，与阶乘类似，所以可以用阶乘逼近答案。">It can be seen from observation that it is similar to factorial, so factorial can be used to approximate the answer.</trans> <trans data-src="首先，对于$$x$$，找出唯一确定的$$n$$和$$r^{\prime}$$，满足$$x=1+2+3+\ldots +n-r^{\prime}(0\leq r^{\prime}< n)$$。">First, for $$x $$, find the uniquely determined $$n $$and $$r ^ { prime} $$, and meet $$x=1+2+3+ ldots+n-r ^ { prime} (0 leq r ^ { prime}<n) $$.</trans> <trans data-src="对$$r^{\prime}$$分类讨论。">Discuss $$r ^ { prime} $$in categories.</trans> <trans data-src="```katex">```katex</trans> <trans data-src="\begin{array}{l}">\begin{array}{l}</trans> <trans data-src="1)r^{\prime}=0:x=2+3+\ldots +(n-1)+(n+1) \\">1)r^{\prime}=0:x=2+3+\ldots +(n-1)+(n+1) \\</trans> <trans data-src="2)r^{\prime}=1:x=2+3+\ldots +n \\">2)r^{\prime}=1:x=2+3+\ldots +n \\</trans> <trans data-src="3)r^{\prime}=2:x=3+4+\ldots +(n-1)+(n+1) \\">3)r^{\prime}=2:x=3+4+\ldots +(n-1)+(n+1) \\</trans> <trans data-src="4)r^{\prime}\geq 3:x=2+3+\ldots +(r^{\prime}-2)+r^{\prime}+\ldots +n">4)r^{\prime}\geq 3:x=2+3+\ldots +(r^{\prime}-2)+r^{\prime}+\ldots +n</trans> <trans data-src="\end{array}">\end{array}</trans> <trans data-src="```">```</trans> <trans data-src="-">-</trans> <trans data-src="$$x\leq 10^9 \Rightarrow n< 10^5$$。">$$x\leq 10^9 \Rightarrow n< 10^5$$。</trans> <trans data-src="预处理阶乘后，每次求出符合条件的$$n$$和$$r^{\prime}$$，对每种情况分类构造即可。">After the factorial is preprocessed, the matching $$n $$and $$r ^ { prime} $$can be calculated each time, and each case can be classified and constructed.</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <stdio.h>">#include <stdio.h></trans> <trans data-src="#include <stdlib.h>">#include <stdlib.h></trans> <trans data-src="#include <stdint.h>">#include <stdint.h></trans> <trans data-src="#include <inttypes.h>">#include <inttypes.h></trans> <trans data-src="#include <math.h>">#include <math.h></trans> <trans data-src="#include <assert.h>">#include <assert.h></trans> <trans data-src="typedef int64_t ll;">typedef int64_t ll;</trans> <trans data-src="const ll MAX_T = 1000000;">const ll MAX_T = 1000000;</trans> <trans data-src="const ll MOD = 1e9 + 7;">const ll MOD = 1e9 + 7;</trans> <trans data-src="ll seri_times[MAX_T];">ll seri_times[MAX_T];</trans> <trans data-src="void init() {">void init() {</trans> <trans data-src="ll temp = 1;">ll temp = 1;</trans> <trans data-src="seri_times[0] = 1;">seri_times[0] = 1;</trans> <trans data-src="for (ll i = 1; i < MAX_T; i++) {">for (ll i = 1; i < MAX_T; i++) {</trans> <trans data-src="temp = (temp * i) % MOD;">temp = (temp * i) % MOD;</trans> <trans data-src="seri_times[i] = temp;">seri_times[i] = temp;</trans> <trans data-src="}">}</trans> <trans data-src="return ;">return ;</trans> <trans data-src="}">}</trans> <trans data-src="/*">/*</trans> <trans data-src="p - x * v = r">p - x * v = r</trans> <trans data-src="x * v + r = 0 (mod p)">x * v + r = 0 (mod p)</trans> <trans data-src="x * r1 + v1 = 0 (mod p)">x * r1 + v1 = 0 (mod p)</trans> <trans data-src="v1 = -x * r1 (mod p)">v1 = -x * r1 (mod p)</trans> <trans data-src="*/">*/</trans> <trans data-src="ll rev_num(ll k) {">ll rev_num(ll k) {</trans> <trans data-src="assert(k);">assert(k);</trans> <trans data-src="if (k == 1) return 1;">if (k == 1) return 1;</trans> <trans data-src="return ((-(MOD / k) * rev_num(MOD % k)) % MOD + MOD) % MOD;">return ((-(MOD / k) * rev_num(MOD % k)) % MOD + MOD) % MOD;</trans> <trans data-src="}">}</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="ll tcase, n, x, r, ret;">ll tcase, n, x, r, ret;</trans> <trans data-src="init();">init();</trans> <trans data-src="scanf("%" PRId64, &tcase);">scanf("%" PRId64, &tcase);</trans> <trans data-src="while (tcase--) {">while (tcase--) {</trans> <trans data-src="scanf("%" PRId64, &n);">scanf("%" PRId64, &n);</trans> <trans data-src="if (__builtin_expect(!!(n == 1), 0)) {">if (__builtin_expect(!!(n == 1), 0)) {</trans> <trans data-src="printf("1\n");">printf("1\n");</trans> <trans data-src="continue;">continue;</trans> <trans data-src="}">}</trans> <trans data-src="x = ((ll)sqrt(2 * n));">x = ((ll)sqrt(2 * n));</trans> <trans data-src="while (x * (x + 1) >> 1 < n) ++x;">while (x * (x + 1) >> 1 < n) ++x;</trans> <trans data-src="r = (x * (x + 1) >> 1) - n;">r = (x * (x + 1) >> 1) - n;</trans> <trans data-src="assert(r >= 0);">assert(r >= 0);</trans> <trans data-src="switch (r) {">switch (r) {</trans> <trans data-src="case 0 :">case 0 :</trans> <trans data-src="ret = seri_times[x + 1] * rev_num(x);">ret = seri_times[x + 1] * rev_num(x);</trans> <trans data-src="break;">break;</trans> <trans data-src="case 1 :">case 1 :</trans> <trans data-src="ret = seri_times[x];">ret = seri_times[x];</trans> <trans data-src="break;">break;</trans> <trans data-src="case 2 :">case 2 :</trans> <trans data-src="ret = seri_times[x + 1] * rev_num(2 * x);">ret = seri_times[x + 1] * rev_num(2 * x);</trans> <trans data-src="break;">break;</trans> <trans data-src="default :">default :</trans> <trans data-src="ret = seri_times[x] * rev_num(r - 1);">ret = seri_times[x] * rev_num(r - 1);</trans> <trans data-src="break;">break;</trans> <trans data-src="}">}</trans> <trans data-src="ret %= MOD;">ret %= MOD;</trans> <trans data-src="printf("%" PRId64 "\n", ret);">printf("%" PRId64 "\n", ret);</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem G Garden of Eden">#Problem G Garden of Eden</trans> <trans data-src="##提交情况：72/221">##Submission status: 72/221</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="树分治+枚举子集/DP">Tree divide and conquer+enumeration subset/DP</trans> <trans data-src="点的编号很小，所以可以用$$(1<< i)$$表示编号$$i$$的结点，问题转化为求权值**或和**为$$K=(1<< k)=1$$的有向路径条数。">The number of points is very small, so $$(1<<i) $$can be used to represent the node with the number of $$i $$. The problem is transformed into the number of directed paths with the weight * * or * * being $$K=(1<<k)=1 $$.</trans> <trans data-src="用树的点分治简化问题。">Simplify the problem by dividing and dividing the points of the tree.</trans> <trans data-src="问题转化为：给定一个集合，求该集合中**或和**为$$K$$的元素对，给出两种做法。">The problem is transformed into: given a set, find the element pairs of * * or * * in the set that are $$K $$, and give two methods.</trans> <trans data-src="1）统计集合中元素值为$$x$$的个数$$num[x]$$，$$ans=\sum_{1\leq x\leq K}num[x]\times \sum_{y\space is\space subset \space of \space x}num[(x\oplus K)|y]$$">1) The number of elements in the statistical set whose value is $$x $$$num [x] $$, $$ans= sum_ {1 leq x leq K} num [x] times sum_ {y space is space subset space of space x} num [(x oplus K) | y]$$</trans> <trans data-src="2)进行dp。$$">2) Perform dp$$</trans> <trans data-src="dp[i][st]$$表示低$$i$$位是$$st$$低$$i$$位的倍集（x是st的倍集：x&st=st），高位和st相同的元素个数。">Dp [i] [st] $$indicates that the low $$i $$bit is a multiple of the low $$i $$bit of $$st $$(x is a multiple of st: x&st=st), and the high bit is the same as the number of elements of st.</trans> <trans data-src="(1<<(i-1))&st==0:$$dp[i][st]=dp[i-1][st]+dp[i-1][st\oplus ((1<<(i-1))]$$">(1<<(i-1))&st==0:$$dp[i][st]=dp[i-1][st]+dp[i-1][st\oplus ((1<<(i-1))]$$</trans> <trans data-src="(1<<(i-1))&st==1:$$dp[i][st]=dp[i-1][st]$$">(1<<(i-1))&st==1:$$dp[i][st]=dp[i-1][st]$$</trans> <trans data-src="```katex">```katex</trans> <trans data-src="ans=\sum_{0\leq x\leq K}num[x]\times dp[k][x\oplus K]">ans=\sum_{0\leq x\leq K}num[x]\times dp[k][x\oplus K]</trans> <trans data-src="```">```</trans> <trans data-src="第一种时间复杂度$$O(nlogn+n\times 3^{k})$$，第二种$$O(nlogn+n\times k\times 2^{k})$$">The first time complexity is $$O (nlogn+n times 3 ^ {k}) $$, and the second is $$O (nlogn+n times k times 2 ^ {k})$$</trans> <trans data-src="对$$k=1$$特殊情况考虑一下（包含起点和终点相同的路径，用上述方法会出现重复计数）。">Consider the special case of $$k=1 $$(including paths with the same starting point and end point, and repeated counting will occur with the above method).</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include<stdio.h>">#include<stdio.h></trans> <trans data-src="#include<string.h>">#include<string.h></trans> <trans data-src="#include<iostream>">#include<iostream></trans> <trans data-src="#include<algorithm>">#include<algorithm></trans> <trans data-src="#include<assert.h>">#include<assert.h></trans> <trans data-src="#include<math.h>">#include<math.h></trans> <trans data-src="#include<vector>">#include<vector></trans> <trans data-src="#define MP make_pair">#define MP make_pair</trans> <trans data-src="#define PII pair<int,int>">#define PII pair<int,int></trans> <trans data-src="#define X first">#define X first</trans> <trans data-src="#define Y second">#define Y second</trans> <trans data-src="#define ll long long">#define ll long long</trans> <trans data-src="#define mem(a, b) memset(a, b, sizeof(a))">#define mem(a, b) memset(a, b, sizeof(a))</trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="const int maxn = 50000+10;">const int maxn = 50000+10;</trans> <trans data-src="const int INF = 0x3f3f3f3f;">const int INF = 0x3f3f3f3f;</trans> <trans data-src="const int maxk = 13;">const int maxk = 13;</trans> <trans data-src="const int maxm = (1<<10)+10;">const int maxm = (1<<10)+10;</trans> <trans data-src="vector<int> g[maxn];">vector<int> g[maxn];</trans> <trans data-src="int n, k, s[maxn], vis[maxn], num[maxn], dp[maxk][maxn], w[maxn];">int n, k, s[maxn], vis[maxn], num[maxn], dp[maxk][maxn], w[maxn];</trans> <trans data-src="ll ans;">ll ans;</trans> <trans data-src="void init(){">void init(){</trans> <trans data-src="mem(vis, 0); ">mem(vis, 0); </trans> <trans data-src="ans = 0;">ans = 0;</trans> <trans data-src="}">}</trans> <trans data-src="PII Find(int u, int f, int sum){">PII Find(int u, int f, int sum){</trans> <trans data-src="s[u] = 1;">s[u] = 1;</trans> <trans data-src="int lar = 0;">int lar = 0;</trans> <trans data-src="PII tmp = MP(INF, 0);">PII tmp = MP(INF, 0);</trans> <trans data-src="for(int i = 0; i < g[u].size(); ">for(int i = 0; i < g[u].size(); </trans> <trans data-src="i ++){">i ++){</trans> <trans data-src="int v = g[u][i];">int v = g[u][i];</trans> <trans data-src="if(v == f || vis[v]) continue;">if(v == f || vis[v]) continue;</trans> <trans data-src="PII x = Find(v, u, sum);">PII x = Find(v, u, sum);</trans> <trans data-src="s[u] += s[v];">s[u] += s[v];</trans> <trans data-src="lar = max(lar, s[v]);">lar = max(lar, s[v]);</trans> <trans data-src="tmp = min(tmp, x);">tmp = min(tmp, x);</trans> <trans data-src="}">}</trans> <trans data-src="lar = max(lar, sum-s[u]);">lar = max(lar, sum-s[u]);</trans> <trans data-src="return min(tmp, MP(lar, u));">return min(tmp, MP(lar, u));</trans> <trans data-src="}">}</trans> <trans data-src="void dfs2(int u, int f, int x){">void dfs2(int u, int f, int x){</trans> <trans data-src="num[x] ++;">num[x] ++;</trans> <trans data-src="s[u]=1;">s[u]=1;</trans> <trans data-src="for(int i = 0; i < g[u].size(); ">for(int i = 0; i < g[u].size(); </trans> <trans data-src="i ++){">i ++){</trans> <trans data-src="int v = g[u][i];">int v = g[u][i];</trans> <trans data-src="if(v == f || vis[v]) continue;">if(v == f || vis[v]) continue;</trans> <trans data-src="dfs2(v, u, x|(1<<w[v]));">dfs2(v, u, x|(1<<w[v]));</trans> <trans data-src="s[u]+=s[v];">s[u]+=s[v];</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="ll cal(int u, int x){">ll cal(int u, int x){</trans> <trans data-src="ll ans = 0;">ll ans = 0;</trans> <trans data-src="for(int i = 0; i < (1<<k); ">for(int i = 0; i < (1<<k); </trans> <trans data-src="i ++) num[i] = 0;">i ++) num[i] = 0;</trans> <trans data-src="dfs2(u, 0, x);">dfs2(u, 0, x);</trans> <trans data-src="for(int i = 0; i < (1<<k); ">for(int i = 0; i < (1<<k); </trans> <trans data-src="i ++) dp[0][i] = num[i];">i ++) dp[0][i] = num[i];</trans> <trans data-src="for(int i = 1; i <= k; i ++){">for(int i = 1; i <= k; i ++){</trans> <trans data-src="for(int j = 0; j < (1<<k); ">for(int j = 0; j < (1<<k); </trans> <trans data-src="j ++){">j ++){</trans> <trans data-src="dp[i][j] = dp[i-1][j];">dp[i][j] = dp[i-1][j];</trans> <trans data-src="if(!(j&(1<<(i-1)))) dp[i][j] += dp[i-1][j^(1<<(i-1))];">if(!(j&(1<<(i-1)))) dp[i][j] += dp[i-1][j^(1<<(i-1))];</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="for(int i = 0; i < (1<<k); ">for(int i = 0; i < (1<<k); </trans> <trans data-src="i ++) ans += 1ll * num[i]*dp[k][i^((1<<k)-1)];">i ++) ans += 1ll * num[i]*dp[k][i^((1<<k)-1)];</trans> <trans data-src="return ans;">return ans;</trans> <trans data-src="}">}</trans> <trans data-src="void dfs(int u, int f, int sum){">void dfs(int u, int f, int sum){</trans> <trans data-src="u = Find(u, f, sum).">u = Find(u, f, sum).</trans> <trans data-src="Y;">Y;</trans> <trans data-src="ans += cal(u, 1<<w[u]); ">ans += cal(u, 1<<w[u]); </trans> <trans data-src="vis[u] = 1;">vis[u] = 1;</trans> <trans data-src="for(int i = 0; i < g[u].size(); ">for(int i = 0; i < g[u].size(); </trans> <trans data-src="i ++){">i ++){</trans> <trans data-src="int v = g[u][i];">int v = g[u][i];</trans> <trans data-src="if(vis[v]) continue;">if(vis[v]) continue;</trans> <trans data-src="ans -= cal(v, (1<<w[u])|(1<<w[v]));">ans -= cal(v, (1<<w[u])|(1<<w[v]));</trans> <trans data-src="}">}</trans> <trans data-src="for(int i = 0; i < g[u].size(); ">for(int i = 0; i < g[u].size(); </trans> <trans data-src="i ++){">i ++){</trans> <trans data-src="int v = g[u][i];">int v = g[u][i];</trans> <trans data-src="if(!vis[v] && s[v] > 1) dfs(v, u, s[v]);">if(!vis[v] && s[v] > 1) dfs(v, u, s[v]);</trans> <trans data-src="}">}</trans> <trans data-src="}">}</trans> <trans data-src="int main()">int main()</trans> <trans data-src="{">{</trans> <trans data-src="while(scanf("%d%d", &n, &k) != ">while(scanf("%d%d", &n, &k) != </trans> <trans data-src="EOF){">EOF){</trans> <trans data-src="for(int i = 1; i <= n; i ++) scanf("%d", &w[i]), w[i] --, g[i].clear();">for(int i = 1; i <= n; i ++) scanf("%d", &w[i]), w[i] --, g[i].clear();</trans> <trans data-src="for(int i = 1; i < n; i ++){">for(int i = 1; i < n; i ++){</trans> <trans data-src="int u, v; ">int u, v; </trans> <trans data-src="scanf("%d%d", &u, &v);">scanf("%d%d", &u, &v);</trans> <trans data-src="g[u].push_back(v), g[v].push_back(u);">g[u].push_back(v), g[v].push_back(u);</trans> <trans data-src="}">}</trans> <trans data-src="if(k == 1) { printf("%lld\n", 1ll*n*n); continue; }">if(k == 1) { printf("%lld\n", 1ll*n*n); continue; }</trans> <trans data-src="init();">init();</trans> <trans data-src="dfs(1, 0, n);">dfs(1, 0, n);</trans> <trans data-src="printf("%lld\n", ans);">printf("%lld\n", ans);</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem H To begin or not to begin">#Problem H To begin or not to begin</trans> <trans data-src="##提交情况：216/298">##Submission: 216/298</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="直接推公式即可。">The formula can be directly deduced.</trans> <trans data-src="先手获胜概率为$$\frac{\lfloor \frac{n+2}{2}\rfloor }{n+1}$$，向下取整。">The first win probability is $$ frac { lffloor frac {n+2} {2} rffloor} {n+1} $$, rounded down.</trans> <trans data-src="n为偶数时，大于$$\frac{1}{2}$$；">When n is an even number, it is greater than $$ frac {1} {2} $$;</trans> <trans data-src="n为奇数时，等于$$\frac{1}{2}$$。">When n is an odd number, it is equal to $$ frac {1} {2} $$.</trans> <trans data-src="所以n为偶数时，先手获胜；">So when n is an even number, the first one wins;</trans> <trans data-src="n为奇数时先手后手获胜概率相同。">When n is an odd number, the probability of winning is the same.</trans> <trans data-src="标准程序">Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <stdio.h>">#include <stdio.h></trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <stdlib.h>">#include <stdlib.h></trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="int main(){">int main(){</trans> <trans data-src="for(int n; cin>>n; ){">for(int n; cin>>n; ){</trans> <trans data-src="puts(n&1?"0":"1");">puts(n&1?"0":"1");</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem I Convex">#Problem I Convex</trans> <trans data-src="##提交情况：216/254">##Submission: 216/254</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="用公式$$\frac{1}{2}\times sin\theta \times a \times b$$求三角形面积再求和">Use the formula $$ frac {1} {2} times sin theta times a times b $$to find the triangle area and then sum it</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <cmath>">#include <cmath></trans> <trans data-src="#include <cstdio>">#include <cstdio></trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="const double pi = acos(-1.0);">const double pi = acos(-1.0);</trans> <trans data-src="int n, d;">int n, d;</trans> <trans data-src="double sum;">double sum;</trans> <trans data-src="int main(){">int main(){</trans> <trans data-src="while(scanf("%d %d", &n, &d) != ">while(scanf("%d %d", &n, &d) != </trans> <trans data-src="EOF){">EOF){</trans> <trans data-src="sum = 0;">sum = 0;</trans> <trans data-src="for(int i = 0, ang; i < n; ++i){">for(int i = 0, ang; i < n; ++i){</trans> <trans data-src="scanf("%d", &ang);">scanf("%d", &ang);</trans> <trans data-src="sum += sin(1.0 * ang * pi / 180);">sum += sin(1.0 * ang * pi / 180);</trans> <trans data-src="}">}</trans> <trans data-src="printf("%.3f\n", 0.5 * d * d * sum);">printf("%.3f\n", 0.5 * d * d * sum);</trans> <trans data-src="}">}</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem J Find Small A">#Problem J Find Small A</trans> <trans data-src="##提交情况：215/360">##Submission: 215/360</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="用位移操作，每次向右移动8位，统计小$$a$$的数量即可。">Use displacement operation, move 8 bits to the right each time, and count the number of small $$a $$.</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include<iostream>">#include<iostream></trans> <trans data-src="#define a1mask (97 << 0)">#define a1mask (97 << 0)</trans> <trans data-src="#define mask1 (0x000000ff)">#define mask1 (0x000000ff)</trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="int cnt_a(uint32_t ind) {">int cnt_a(uint32_t ind) {</trans> <trans data-src="uint32_t ret = 0;">uint32_t ret = 0;</trans> <trans data-src="while(ind) {">while(ind) {</trans> <trans data-src="ret += !!">ret += !!</trans> <trans data-src="((ind & mask1) == a1mask);">((ind & mask1) == a1mask);</trans> <trans data-src="ind >>= 8;">ind >>= 8;</trans> <trans data-src="}">}</trans> <trans data-src="return ret;">return ret;</trans> <trans data-src="}">}</trans> <trans data-src="int main() {">int main() {</trans> <trans data-src="int32_t n, ai, sum = 0;">int32_t n, ai, sum = 0;</trans> <trans data-src="scanf("%d", &n);">scanf("%d", &n);</trans> <trans data-src="for (int32_t i = 0; i < n; i++) {">for (int32_t i = 0; i < n; i++) {</trans> <trans data-src="scanf("%d", &ai);">scanf("%d", &ai);</trans> <trans data-src="sum += cnt_a(ai);">sum += cnt_a(ai);</trans> <trans data-src="}">}</trans> <trans data-src="printf("%d\n", sum);">printf("%d\n", sum);</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> <trans data-src="#Problem K Guess the number">#Problem K Guess the number</trans> <trans data-src="##提交情况：20/73">##Submission: 20/73</trans> <trans data-src="##解题思路">##Solutions</trans> <trans data-src="题目需要回答两个问题：1、最优策略需要猜几次；">The question needs to answer two questions: 1. How many guesses are needed for the optimal strategy;</trans> <trans data-src="2、有多少种最优策略。">2. How many optimal strategies are there.</trans> <trans data-src="1、由题意，易得动规方程：$$f(x)=min(max(y,1+f(x-y))|y\in [1,x])$$，此方程复杂度太高，可以作为找规律方法的基础。">1. According to the meaning of the question, it is easy to get the dynamic gauge equation: $$f (x)=min (max (y, 1+f (x-y)) | y in [1, x]) $$. The complexity of this equation is too high, which can be used as the basis for finding laws.</trans> <trans data-src="现在我们采用另一种方式来思考这个问题：">Now let's think about this in another way:</trans> <trans data-src="现在来反推最优策略，设函数$$y=f(x)$$是区间长度位$$x$$时最优策略的猜数次数，并且容易得知以下事实：">Now let's reverse the optimal policy. Let the function $$y=f (x) $$be the number of guesses of the optimal policy when the interval length bit is $$x $$, and it is easy to know the following facts:</trans> <trans data-src="当$$x_{1}\leq x_{2}$$时有$$f(x_{1})\leq f(x_{2})$$">When $$x_ {1} leq x_ {2} $$, there is $$f (x_ {1}) leq f (x_ {2})$$</trans> <trans data-src="所以，$$y=f(x)\geq 1+f(x-y)$$，$$1+f(x-y)$$是$$f(x)$$的下限，现在讨论，$$f(x)$$到下限时的情况。">So, $$y=f (x) geq 1+f (x-y) $$, $$1+f (x-y) $$is the lower limit of $$f (x) $$. Now let's discuss the situation when $$f (x) $$reaches the lower limit.</trans> <trans data-src="则$$f(x-f(x))=y_{1}=y-1$$，同时可得$$f(x+y+1)=y+1$$，则由公式可得如下$$f(x)$$到达下限时的$$x$$值">Then $$f (x-f (x))=y_ {1}=y-1 $$, and $$f (x+y+1)=y+1 $$can be obtained from the formula as follows: $$x $$value when $$f (x) $$reaches the lower limit</trans> <trans data-src="```katex">```katex</trans> <trans data-src="\begin{array}{}">\begin{array}{}</trans> <trans data-src="f(1)=1,f(3)=2,f(6)3,f(10)=4 \\">f(1)=1,f(3)=2,f(6)3,f(10)=4 \\</trans> <trans data-src="f(15)=5,f(21)=6,f(28)=7,f(36)=8">f(15)=5,f(21)=6,f(28)=7,f(36)=8</trans> <trans data-src="\end{array}">\end{array}</trans> <trans data-src="```">```</trans> <trans data-src="则可知，$$f([2,3])=f(3)=2, f([4,6])=f(6)=3\ldots $$，由此我们得到了$$f(x)$$的值。">Then we can see that $$f ([2,3])=f (3)=2, f ([4,6])=f (6)=3 ldots $$, from which we get the value of $$f (x) $$.</trans> <trans data-src="2、现在来讨论最优策略有多少种。">2. Now let's discuss how many kinds of optimal strategies are available.</trans> <trans data-src="由动规方程$$max(y,1+f(x-y))$$其中$$f(x-y)$$中$$y$$的上限为$$f(x)$$，$$f(x-y)$$的上限是$$f(x)-1$$，这两个上限大大缩小了动规方程中$$y$$的取值范围。">From the dynamic gauge equation $$max (y, 1+f (x-y)) $$, where the upper limit of $$y $$in $$f (x-y) $$is $$f (x) $$, and the upper limit of $$f (x-y) $$is $$f (x) - 1 $$, these two upper limits greatly narrow the value range of $$y $$in the dynamic gauge equation.</trans> <trans data-src="具体的，请看标程。">See the range for details.</trans> <trans data-src="##标准程序">##Standard procedures</trans> <trans data-src="```c++">```c++</trans> <trans data-src="#include <iostream>">#include <iostream></trans> <trans data-src="#include <stdint.h>">#include <stdint.h></trans> <trans data-src="#include <inttypes.h>">#include <inttypes.h></trans> <trans data-src="#include <algorithm>">#include <algorithm></trans> <trans data-src="#define Maxn 5000005">#define Maxn 5000005</trans> <trans data-src="#define Mod_Num 100000073">#define Mod_Num 100000073</trans> <trans data-src="using namespace std;">using namespace std;</trans> <trans data-src="typedef int64_t inta;">typedef int64_t inta;</trans> <trans data-src="const bool Output_flag = true;">const bool Output_flag = true;</trans> <trans data-src="inta many_Time[Maxn + 5];">inta many_Time[Maxn + 5];</trans> <trans data-src="inta many_Acti[Maxn + 5];">inta many_Acti[Maxn + 5];</trans> <trans data-src="void init() {">void init() {</trans> <trans data-src="memset(many_Time, 0, sizeof(many_Time));">memset(many_Time, 0, sizeof(many_Time));</trans> <trans data-src="memset(many_Acti, 0, sizeof(many_Acti));">memset(many_Acti, 0, sizeof(many_Acti));</trans> <trans data-src="}">}</trans> <trans data-src="int64_t max(inta a,inta b)">int64_t max(inta a,inta b)</trans> <trans data-src="{">{</trans> <trans data-src="if (a > b) return a;">if (a > b) return a;</trans> <trans data-src="return b;">return b;</trans> <trans data-src="}">}</trans> <trans data-src="int main()">int main()</trans> <trans data-src="{">{</trans> <trans data-src="init();">init();</trans> <trans data-src="inta *p = many_Time;">inta *p = many_Time;</trans> <trans data-src="inta *q = many_Acti;">inta *q = many_Acti;</trans> <trans data-src="p[1] = 1; ">p[1] = 1; </trans> <trans data-src="p[0] = 0;">p[0] = 0;</trans> <trans data-src="q[1] = 1; ">q[1] = 1; </trans> <trans data-src="q[0] = 1;">q[0] = 1;</trans> <trans data-src="int32_t i, j, t, total_num, pre_total_num;">int32_t i, j, t, total_num, pre_total_num;</trans> <trans data-src="i = 2; ">i = 2; </trans> <trans data-src="j = 2; ">j = 2; </trans> <trans data-src="pre_total_num = 1;">pre_total_num = 1;</trans> <trans data-src="while (j < Maxn) {">while (j < Maxn) {</trans> <trans data-src="t = i;">t = i;</trans> <trans data-src="total_num = pre_total_num + 1;">total_num = pre_total_num + 1;</trans> <trans data-src="total_num %= Mod_Num;">total_num %= Mod_Num;</trans> <trans data-src="pre_total_num = 0;">pre_total_num = 0;</trans> <trans data-src="while (j < Maxn && t--) {">while (j < Maxn && t--) {</trans> <trans data-src="p[j] = i;">p[j] = i;</trans> <trans data-src="q[j] = total_num;">q[j] = total_num;</trans> <trans data-src="total_num = (total_num - q[j - i] + Mod_Num) % Mod_Num;">total_num = (total_num - q[j - i] + Mod_Num) % Mod_Num;</trans> <trans data-src="pre_total_num += q[j];">pre_total_num += q[j];</trans> <trans data-src="pre_total_num %= Mod_Num;">pre_total_num %= Mod_Num;</trans> <trans data-src="j++;">j++;</trans> <trans data-src="}">}</trans> <trans data-src="i++;">i++;</trans> <trans data-src="}">}</trans> <trans data-src="int32_t a,b;">int32_t a,b;</trans> <trans data-src="while (scanf("%d%d",&a,&b)!=">while (scanf("%d%d",&a,&b)!=</trans> <trans data-src="EOF)">EOF)</trans> <trans data-src="printf("%" PRId64 " %" PRId64 "\n",p[b-a+1],q[b-a+1]);">printf("%" PRId64 " %" PRId64 "\n",p[b-a+1],q[b-a+1]);</trans> <trans data-src="return 0;">return 0;</trans> <trans data-src="}">}</trans> <trans data-src="```">```</trans> ]]> seven https://lo-li.net/1391-1391.html#comments https://lo-li.net/feed/1391-1391.html