(1) 根据给定文法，先对文法进行解析，构造识别活前缀的 DFA 并输出； (2) 根据 DFA 构造 LR 分析表并输出； (3) 分析给定表达式是否是该文法识别的正确的算术表达式 (要求输出归约过程) (4) 假如给定表达式文法为： G(E’): E’→#E# E →E+T | T T →T*F |F F →(E)|i 分析的句子可为: (i+i)*i 和 i+i)*i

首先，我们需要对给定文法进行解析，构造识别活前缀的DFA，并输出。

文法为：

G(E’): 
E’ → #E# 
E → E+T | T 
T → T*F | F 
F → (E) | i

构造识别活前缀的DFA的步骤如下：

1. 对每个产生式添加一个虚拟起始符号S，并将其作为所有产生式的公共起点。

G(E’): 
S → #E# 
E’ → #E# 
E → E+T | T 
T → T*F | F 
F → (E) | i

2. 对每个产生式右部的符号集合构造一个状态。

状态0: S → .#E#
状态1: S → #.E#
状态2: E → .E+T
状态3: E → .T
状态4: T → .T*F
状态5: T → .F
状态6: F → .(E)
状态7: F → .i
状态8: E → E+.T
状态9: T → T*.F
状态10: F → (E). 

3. 对每个状态构造出所有可能的活前缀。

状态0: .#E# 
状态1: #.E# 
状态2: .E+T, # 
状态3: .T, # ,+
状态4: .T*F, #, + 
状态5: .F, #, +, * 
状态6: .(E), #, +, * 
状态7: .i, #, +, * 
状态8: E+.T, # 
状态9: T*.F, #, + 
状态10: (E)., #, +, * 

4. 根据状态转移，构造DFA。

状态0: .#E#  --#-->  #.E# 
状态1: #.E#  --E-->  E.+T, # 
状态2: .E+T, #  --#-->  #.E# 
状态3: .T, # ,+  --+-->  E+.T, # 
状态4: .T*F, #, +  --*-->  T*.F, #, + 
状态5: .F, #, +, *  --+-->  T+.F, #, + 
状态6: .(E), #, +, *  --(-->  E.+(T), #, +, * 
状态7: .i, #, +, *  --i-->  F.i, #, +, * 
状态8: E+.T, #  --#-->  #.E# 
状态9: T*.F, #, +  --+-->  E*.F, #, +, * 
状态10: (E)., #, +, *  --)--  F.(E), #, +, *

最终得到的DFA如下图所示：


接下来，我们根据DFA构造LR分析表，并输出。

根据DFA构造LR分析表的步骤如下：

1. 对于每个状态，确定每个终结符和非终结符的移进和规约操作。

状态0: .#E#  --#-->  #.E# 
    # -> 移进, E -> GOTO(1), T -> GOTO(2), F -> GOTO(3)
状态1: #.E#  --E-->  E.+T, # 
    + -> 移进, T -> GOTO(4), F -> GOTO(3)
状态2: .E+T, #  --#-->  #.E# 
    # -> 移进, T -> GOTO(5), F -> GOTO(3)
状态3: .T, # ,+  --+-->  E+.T, # 
    + -> 移进, # -> 接受
状态4: .T*F, #, +  --*-->  T*.F, #, + 
    * -> 移进, F -> GOTO(6)
状态5: .F, #, +, *  --+-->  T+.F, #, + 
    + -> 移进, * -> 移进, # -> 规约F -> i
状态6: .(E), #, +, *  --(-->  E.+(T), #, +, * 
    ( -> 移进, E -> GOTO(7), T -> GOTO(2), F -> GOTO(3)
状态7: .i, #, +, *  --i-->  F.i, #, +, * 
    i -> 移进, # -> 规约F -> i
状态8: E+.T, #  --#-->  #.E# 
    # -> 移进, T -> GOTO(9), F -> GOTO(3)
状态9: T*.F, #, +  --+-->  E*.F, #, +, * 
    + -> 移进, * -> 移进, # -> 规约T -> T*F, F -> GOTO(10)
状态10: (E)., #, +, *  --)--  F.(E), #, +, * 
    ) -> 移进, # -> 规约F -> (E)

2. 根据每个状态的移进和规约操作，构造LR分析表。

          #       +       *       (       )       i       E       T       F   
------------------------------------------------------------------------------
  0       s2              s4      s6                              s7          
  1       acc     s2              s6                              s7          
  2       s2              s4      s6                              s7          
  3               s4      r3      r3                                      r3  
  4       s2              s4      s6                              s7          
  5                       s8      s6                              s7          
  6       s2              s4      s6                              s7          
  7               r1      r1      r1                                      r1  
  8       s2              s4      s6                              s7          
  9                       s4      s6                              s7      s10 
  10                      r2      r2                                      r2  

最终得到的LR分析表如上所示。

接下来，我们分析给定的表达式是否是该文法识别的正确的算术表达式，并输出归约过程。

首先，我们先将给定的表达式拆分成符号序列：(i+i)*i

接下来，我们使用上一步构造出的LR分析表来进行分析。

1. 将状态0入栈。
2. 读入符号'('，查看状态0对'('的移进操作，得到状态6，并将其入栈。
3. 读入符号i，查看状态6对i的移进操作，得到状态7，并将其入栈。
4. 读入符号'+'，查看状态7对'+'的移进操作，得到状态5，并将其入栈。
5. 读入符号i，查看状态5对i的移进操作，得到状态7，并将其入栈。
6. 读入符号')'，查看状态7对')'的移进操作，得到状态10，并将其入栈。
7. 读入符号'*'，查看状态10对'*'的移进操作，得到状态9，并将其入栈。
8. 读入符号i，查看状态9对i的移进操作，得到状态7，并将其入栈。
9. 读入符号#，查看状态7对#的规约操作，得到状态1，并将其入栈。
10. 查看状态1对#的接受操作，分析完成。

因此，我们可以得出结论，给定的表达式(i+i)*i是该文法识别的正确算术表达式，并且归约过程如下所示：

状态栈    符号栈    输入串    动作
-----------------------------------------------------------
0        #        (i+i)*i  移进
6,7      #(i     +i)*i    移进
7        #(i+i   )*i      移进
5,7      #(i+i*  i        移进
7        #(i+i*i )        移进
10       #(i+i)*i#        移进
9,7      #(i+i)*i#i       移进
7        #(i+i)*i#i       规约F -> i
5,7      #(i+i)*i#F       规约T -> T*F
9,5,7    #(i+i)*i#T       规约E -> E+T
1        #E#              接受

因此，我们可以看到，给定的表达式(i+i)*i是该文法识别的正确算术表达式，并且归约过程如上所示。